notebook.community

Edit and run

Julia is Open - whos(), methods(), @which, ...

Julia is an open-source project, source being entirely hosted on github: http://github.com/julialang

The code consists of (actual numbers may differ):

  • 29K lines of C/C++
  • 6K lines of scheme
  • 68K lines of julia

Julia uses LLVM which itself has 680K lines of code. Therefore, Julia is very compact, compared to other languages, like LLVM's C compiler clang (513K lines of code) or gcc (3,530K lines). This makes it easy to read the actuall code and get full information, in spite the fact that some parts of the documentation are insufficient. Julia's "navigating" system, consisting of commands whos(), methods() and @which, makes this even easier.

Further, the Base (core) of Julia is kept small, and the rest of the functionality is obtained through packages. Since packages are written in Julia, they are navigated on the same way.

In this notebook, we demonstrate how to get help and navigate the source code.

Prerequisites

Basic knowledge of programming in any language.

Read Methods section of the Julia manual. (5 min)

Competences

The reader should be able to read the code and be able to find and understand calling sequences and outputs of any function.

Credits

Some examples are taken from The Julia Manual.

Operators +, * and ⋅

Consider operators +, * and ⋅, the first two of them seem rather basic in any language. The ⋅ symbol is typed as LaTeX command \cdot + Tab.

?+ gives some information, which is vary sparse. We would expect more details, and we also suspect that + can be used in more ways that just hose two.

?* explaind more instances where * can be used, but the text itself is vague and not sufficient.

?⋅ appears to be what we expect fro the dot product off two vectors.





In [1]:



    


?+



    


















    






search: + .+











    
Out[1]:








+(x, y...)


Addition operator. x+y+z+... calls this function with all arguments, i.e. +(x, y, z, ...).



dt::Date + t::Time -> DateTime


The addition of a Date with a Time produces a DateTime. The hour, minute, second, and millisecond parts of the Time are used along with the year, month, and day of the Date to create the new DateTime. Non-zero microseconds or nanoseconds in the Time type will result in an InexactError being thrown.


















In [2]:



    


?*



    


















    






search: * .*











    
Out[2]:








*(s::AbstractString, t::AbstractString)


Concatenate strings. The * operator is an alias to this function.


Example


jldoctest
julia> "Hello " * "world"
"Hello world"



*(x, y...)


Multiplication operator. x*y*z*... calls this function with all arguments, i.e. *(x, y, z, ...).



*(A::AbstractMatrix, B::AbstractMatrix)


Matrix multiplication.


Example


jldoctest
julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Array{Int64,2}:
 2  1
 1  1


















In [3]:



    


?⋅



    


















    






"⋅" can be typed by \cdot<tab>

search: ⋅











    
Out[3]:








dot(x, y)
⋅(x,y)


Compute the dot product. For complex vectors, the first vector is conjugated.


Example


jldoctest
julia> dot([1; 1], [2; 3])
5

julia> dot([im; im], [1; 1])
0 - 2im



dot(n, X, incx, Y, incy)


Dot product of two vectors consisting of n elements of array X with stride incx and n elements of array Y with stride incy.


Example:


jldoctest
julia> dot(10, ones(10), 1, ones(20), 2)
10.0

methods()

Julia functions have a feature called multiple dispatch, which means that the method depends on the name AND the input. Full range of existing methods for certain function name is given by the methods() command.

Running methods(+) sheds a completely differfent light on +.

The great IJulia feature is that the links to the source code where the respective version of the function is defined, are readily provided.





In [4]:



    


?methods



    


















    






search: methods methodswith method_exists Method MethodTable MethodError











    
Out[4]:








methods(f, [types])


Returns the method table for f.


If types is specified, returns an array of methods whose types match.

The "+" operator

N.B. For convenience, Left click on the left area of the Out[] cell toggles scrolling. Double click collapses the output completely.





In [5]:



    


methods(+)



    


















    
Out[5]:






180 methods for generic function +:
  •  +(x::Bool, z::Complex{Bool}) at complex.jl:232
    •  
  •  +(x::Bool, y::Bool) at bool.jl:89
    •  
  •  +(x::Bool) at bool.jl:86
    •  
  •  +{T<:AbstractFloat}(x::Bool, y::T) at bool.jl:96
    •  
  •  +(x::Bool, z::Complex) at complex.jl:239
    •  
  •  +(a::Float16, b::Float16) at float.jl:372
    •  
  •  +(x::Float32, y::Float32) at float.jl:374
    •  
  •  +(x::Float64, y::Float64) at float.jl:375
    •  
  •  +(z::Complex{Bool}, x::Bool) at complex.jl:233
    •  
  •  +(z::Complex{Bool}, x::Real) at complex.jl:247
    •  
  •  +(x::Char, y::Integer) at char.jl:40
    •  
  •  +(c::BigInt, x::BigFloat) at mpfr.jl:312
    •  
  •  +(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) at gmp.jl:334
    •  
  •  +(a::BigInt, b::BigInt, c::BigInt, d::BigInt) at gmp.jl:327
    •  
  •  +(a::BigInt, b::BigInt, c::BigInt) at gmp.jl:321
    •  
  •  +(x::BigInt, y::BigInt) at gmp.jl:289
    •  
  •  +(x::BigInt, c::Union{UInt16, UInt32, UInt64, UInt8}) at gmp.jl:346
    •  
  •  +(x::BigInt, c::Union{Int16, Int32, Int64, Int8}) at gmp.jl:362
    •  
  •  +(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat, e::BigFloat) at mpfr.jl:460
    •  
  •  +(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat) at mpfr.jl:453
    •  
  •  +(a::BigFloat, b::BigFloat, c::BigFloat) at mpfr.jl:447
    •  
  •  +(x::BigFloat, c::BigInt) at mpfr.jl:308
    •  
  •  +(x::BigFloat, y::BigFloat) at mpfr.jl:277
    •  
  •  +(x::BigFloat, c::Union{UInt16, UInt32, UInt64, UInt8}) at mpfr.jl:284
    •  
  •  +(x::BigFloat, c::Union{Int16, Int32, Int64, Int8}) at mpfr.jl:292
    •  
  •  +(x::BigFloat, c::Union{Float16, Float32, Float64}) at mpfr.jl:300
    •  
  •  +(B::BitArray{2}, J::UniformScaling) at linalg/uniformscaling.jl:59
    •  
  •  +(a::Base.Pkg.Resolve.VersionWeights.VWPreBuildItem, b::Base.Pkg.Resolve.VersionWeights.VWPreBuildItem) at pkg/resolve/versionweight.jl:87
    •  
  •  +(a::Base.Pkg.Resolve.VersionWeights.VWPreBuild, b::Base.Pkg.Resolve.VersionWeights.VWPreBuild) at pkg/resolve/versionweight.jl:135
    •  
  •  +(a::Base.Pkg.Resolve.VersionWeights.VersionWeight, b::Base.Pkg.Resolve.VersionWeights.VersionWeight) at pkg/resolve/versionweight.jl:197
    •  
  •  +(a::Base.Pkg.Resolve.MaxSum.FieldValues.FieldValue, b::Base.Pkg.Resolve.MaxSum.FieldValues.FieldValue) at pkg/resolve/fieldvalue.jl:44
    •  
  •  +(x::Base.Dates.CompoundPeriod, y::Base.Dates.CompoundPeriod) at dates/periods.jl:349
    •  
  •  +(x::Base.Dates.CompoundPeriod, y::Base.Dates.Period) at dates/periods.jl:347
    •  
  •  +(x::Base.Dates.CompoundPeriod, y::Base.Dates.TimeType) at dates/periods.jl:387
    •  
  •  +(x::Date, y::Base.Dates.Day) at dates/arithmetic.jl:77
    •  
  •  +(x::Date, y::Base.Dates.Week) at dates/arithmetic.jl:75
    •  
  •  +(dt::Date, z::Base.Dates.Month) at dates/arithmetic.jl:58
    •  
  •  +(dt::Date, y::Base.Dates.Year) at dates/arithmetic.jl:32
    •  
  •  +(dt::Date, t::Base.Dates.Time) at dates/arithmetic.jl:20
    •  
  •  +(t::Base.Dates.Time, dt::Date) at dates/arithmetic.jl:24
    •  
  •  +(x::Base.Dates.Time, y::Base.Dates.TimePeriod) at dates/arithmetic.jl:81
    •  
  •  +(dt::DateTime, z::Base.Dates.Month) at dates/arithmetic.jl:52
    •  
  •  +(dt::DateTime, y::Base.Dates.Year) at dates/arithmetic.jl:28
    •  
  •  +(x::DateTime, y::Base.Dates.Period) at dates/arithmetic.jl:79
    •  
  •  +(y::AbstractFloat, x::Bool) at bool.jl:98
    •  
  •  +{T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}(x::T, y::T) at int.jl:32
    •  
  •  +(x::Integer, y::Ptr) at pointer.jl:128
    •  
  •  +(z::Complex, w::Complex) at complex.jl:221
    •  
  •  +(z::Complex, x::Bool) at complex.jl:240
    •  
  •  +(x::Real, z::Complex{Bool}) at complex.jl:246
    •  
  •  +(x::Real, z::Complex) at complex.jl:258
    •  
  •  +(z::Complex, x::Real) at complex.jl:259
    •  
  •  +(x::Rational, y::Rational) at rational.jl:245
    •  
  •  +(x::Integer, y::Char) at char.jl:41
    •  
  •  +(i::Integer, index::CartesianIndex) at multidimensional.jl:110
    •  
  •  +(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigInt) at gmp.jl:350
    •  
  •  +(c::Union{Int16, Int32, Int64, Int8}, x::BigInt) at gmp.jl:363
    •  
  •  +(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigFloat) at mpfr.jl:288
    •  
  •  +(c::Union{Int16, Int32, Int64, Int8}, x::BigFloat) at mpfr.jl:296
    •  
  •  +(c::Union{Float16, Float32, Float64}, x::BigFloat) at mpfr.jl:304
    •  
  •  +(x::Irrational, y::Irrational) at irrationals.jl:109
    •  
  •  +(x::Real, r::Base.Use_StepRangeLen_Instead) at deprecated.jl:1232
    •  
  •  +(x::Number) at operators.jl:399
    •  
  •  +{T<:Number}(x::T, y::T) at promotion.jl:335
    •  
  •  +(x::Number, y::Number) at promotion.jl:249
    •  
  •  +(x::Real, r::AbstractUnitRange) at range.jl:721
    •  
  •  +(x::Number, r::AbstractUnitRange) at range.jl:723
    •  
  •  +(x::Number, r::StepRangeLen) at range.jl:726
    •  
  •  +(x::Number, r::LinSpace) at range.jl:730
    •  
  •  +(x::Number, r::Range) at range.jl:724
    •  
  •  +(r::Range, x::Number) at range.jl:732
    •  
  •  +(r1::OrdinalRange, r2::OrdinalRange) at range.jl:882
    •  
  •  +{T}(r1::LinSpace{T}, r2::LinSpace{T}) at range.jl:889
    •  
  •  +{R<:Base.TwicePrecision, T}(r1::StepRangeLen{T,R,S} where S, r2::StepRangeLen{T,R,S} where S) at twiceprecision.jl:300
    •  
  •  +{T, S}(r1::StepRangeLen{T,S,S} where S, r2::StepRangeLen{T,S,S} where S) at range.jl:905
    •  
  •  +(r1::Union{LinSpace, OrdinalRange, StepRangeLen}, r2::Union{LinSpace, OrdinalRange, StepRangeLen}) at range.jl:897
    •  
  •  +(x::Base.TwicePrecision, y::Number) at twiceprecision.jl:455
    •  
  •  +(x::Number, y::Base.TwicePrecision) at twiceprecision.jl:458
    •  
  •  +{T}(x::Base.TwicePrecision{T}, y::Base.TwicePrecision{T}) at twiceprecision.jl:461
    •  
  •  +(x::Base.TwicePrecision, y::Base.TwicePrecision) at twiceprecision.jl:465
    •  
  •  +(x::Ptr, y::Integer) at pointer.jl:126
    •  
  •  +(A::BitArray, B::BitArray) at bitarray.jl:1177
    •  
  •  +(A::SymTridiagonal, B::SymTridiagonal) at linalg/tridiag.jl:128
    •  
  •  +(A::Tridiagonal, B::Tridiagonal) at linalg/tridiag.jl:624
    •  
  •  +(A::UpperTriangular, B::UpperTriangular) at linalg/triangular.jl:419
    •  
  •  +(A::LowerTriangular, B::LowerTriangular) at linalg/triangular.jl:420
    •  
  •  +(A::UpperTriangular, B::Base.LinAlg.UnitUpperTriangular) at linalg/triangular.jl:421
    •  
  •  +(A::LowerTriangular, B::Base.LinAlg.UnitLowerTriangular) at linalg/triangular.jl:422
    •  
  •  +(A::Base.LinAlg.UnitUpperTriangular, B::UpperTriangular) at linalg/triangular.jl:423
    •  
  •  +(A::Base.LinAlg.UnitLowerTriangular, B::LowerTriangular) at linalg/triangular.jl:424
    •  
  •  +(A::Base.LinAlg.UnitUpperTriangular, B::Base.LinAlg.UnitUpperTriangular) at linalg/triangular.jl:425
    •  
  •  +(A::Base.LinAlg.UnitLowerTriangular, B::Base.LinAlg.UnitLowerTriangular) at linalg/triangular.jl:426
    •  
  •  +(A::Base.LinAlg.AbstractTriangular, B::Base.LinAlg.AbstractTriangular) at linalg/triangular.jl:427
    •  
  •  +(A::Symmetric, x::Bool) at linalg/symmetric.jl:274
    •  
  •  +(A::Symmetric, x::Number) at linalg/symmetric.jl:276
    •  
  •  +(A::Hermitian, x::Bool) at linalg/symmetric.jl:274
    •  
  •  +(A::Hermitian, x::Real) at linalg/symmetric.jl:276
    •  
  •  +(Da::Diagonal, Db::Diagonal) at linalg/diagonal.jl:140
    •  
  •  +(A::Bidiagonal, B::Bidiagonal) at linalg/bidiag.jl:330
    •  
  •  +(UL::UpperTriangular, J::UniformScaling) at linalg/uniformscaling.jl:72
    •  
  •  +(UL::Base.LinAlg.UnitUpperTriangular, J::UniformScaling) at linalg/uniformscaling.jl:75
    •  
  •  +(UL::LowerTriangular, J::UniformScaling) at linalg/uniformscaling.jl:72
    •  
  •  +(UL::Base.LinAlg.UnitLowerTriangular, J::UniformScaling) at linalg/uniformscaling.jl:75
    •  
  •  +(A::Array, B::SparseMatrixCSC) at sparse/sparsematrix.jl:1541
    •  
  •  +(x::Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T, y::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) at sparse/sparsevector.jl:1340
    •  
  •  +(x::Union{Base.ReshapedArray{#s268,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s268,N}, SubArray{#s268,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s268<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/periods.jl:358
    •  
  •  +(A::SparseMatrixCSC, J::UniformScaling) at sparse/sparsematrix.jl:3608
    •  
  •  +{TA, TJ}(A::AbstractArray{TA,2}, J::UniformScaling{TJ}) at linalg/uniformscaling.jl:119
    •  
  •  +(A::Diagonal, B::Bidiagonal) at linalg/special.jl:113
    •  
  •  +(A::Bidiagonal, B::Diagonal) at linalg/special.jl:114
    •  
  •  +(A::Diagonal, B::Tridiagonal) at linalg/special.jl:113
    •  
  •  +(A::Tridiagonal, B::Diagonal) at linalg/special.jl:114
    •  
  •  +(A::Diagonal, B::Array{T,2} where T) at linalg/special.jl:113
    •  
  •  +(A::Array{T,2} where T, B::Diagonal) at linalg/special.jl:114
    •  
  •  +(A::Bidiagonal, B::Tridiagonal) at linalg/special.jl:113
    •  
  •  +(A::Tridiagonal, B::Bidiagonal) at linalg/special.jl:114
    •  
  •  +(A::Bidiagonal, B::Array{T,2} where T) at linalg/special.jl:113
    •  
  •  +(A::Array{T,2} where T, B::Bidiagonal) at linalg/special.jl:114
    •  
  •  +(A::Tridiagonal, B::Array{T,2} where T) at linalg/special.jl:113
    •  
  •  +(A::Array{T,2} where T, B::Tridiagonal) at linalg/special.jl:114
    •  
  •  +(A::SymTridiagonal, B::Tridiagonal) at linalg/special.jl:122
    •  
  •  +(A::Tridiagonal, B::SymTridiagonal) at linalg/special.jl:123
    •  
  •  +(A::SymTridiagonal, B::Array{T,2} where T) at linalg/special.jl:122
    •  
  •  +(A::Array{T,2} where T, B::SymTridiagonal) at linalg/special.jl:123
    •  
  •  +(A::Diagonal, B::SymTridiagonal) at linalg/special.jl:131
    •  
  •  +(A::SymTridiagonal, B::Diagonal) at linalg/special.jl:132
    •  
  •  +(A::Bidiagonal, B::SymTridiagonal) at linalg/special.jl:131
    •  
  •  +(A::SymTridiagonal, B::Bidiagonal) at linalg/special.jl:132
    •  
  •  +(A::Diagonal, B::UpperTriangular) at linalg/special.jl:143
    •  
  •  +(A::UpperTriangular, B::Diagonal) at linalg/special.jl:144
    •  
  •  +(A::Diagonal, B::Base.LinAlg.UnitUpperTriangular) at linalg/special.jl:143
    •  
  •  +(A::Base.LinAlg.UnitUpperTriangular, B::Diagonal) at linalg/special.jl:144
    •  
  •  +(A::Diagonal, B::LowerTriangular) at linalg/special.jl:143
    •  
  •  +(A::LowerTriangular, B::Diagonal) at linalg/special.jl:144
    •  
  •  +(A::Diagonal, B::Base.LinAlg.UnitLowerTriangular) at linalg/special.jl:143
    •  
  •  +(A::Base.LinAlg.UnitLowerTriangular, B::Diagonal) at linalg/special.jl:144
    •  
  •  +(A::Base.LinAlg.AbstractTriangular, B::SymTridiagonal) at linalg/special.jl:150
    •  
  •  +(A::SymTridiagonal, B::Base.LinAlg.AbstractTriangular) at linalg/special.jl:151
    •  
  •  +(A::Base.LinAlg.AbstractTriangular, B::Tridiagonal) at linalg/special.jl:150
    •  
  •  +(A::Tridiagonal, B::Base.LinAlg.AbstractTriangular) at linalg/special.jl:151
    •  
  •  +(A::Base.LinAlg.AbstractTriangular, B::Bidiagonal) at linalg/special.jl:150
    •  
  •  +(A::Bidiagonal, B::Base.LinAlg.AbstractTriangular) at linalg/special.jl:151
    •  
  •  +(A::Base.LinAlg.AbstractTriangular, B::Array{T,2} where T) at linalg/special.jl:150
    •  
  •  +(A::Array{T,2} where T, B::Base.LinAlg.AbstractTriangular) at linalg/special.jl:151
    •  
  •  +(Y::Union{Base.ReshapedArray{#s267,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s267,N}, SubArray{#s267,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s267<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}, x::Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/periods.jl:363
    •  
  •  +(X::Union{Base.ReshapedArray{#s266,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s266,N}, SubArray{#s266,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s266<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}, Y::Union{Base.ReshapedArray{#s265,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s265,N}, SubArray{#s265,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s265<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/periods.jl:364
    •  
  •  +(x::Union{Base.ReshapedArray{#s268,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s268,N}, SubArray{#s268,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s268<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}, y::Base.Dates.TimeType) at dates/arithmetic.jl:86
    •  
  •  +(r::Range{#s268} where #s268<:Base.Dates.TimeType, x::Base.Dates.Period) at dates/ranges.jl:47
    •  
  •  +(A::SparseMatrixCSC, B::SparseMatrixCSC) at sparse/sparsematrix.jl:1537
    •  
  •  +(A::SparseMatrixCSC, B::Array) at sparse/sparsematrix.jl:1540
    •  
  •  +(x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv, y::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) at sparse/sparsevector.jl:1339
    •  
  •  +(x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv, y::Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T) at sparse/sparsevector.jl:1341
    •  
  •  +(x::AbstractArray{#s45,N} where N where #s45<:Number) at abstractarraymath.jl:95
    •  
  •  +(A::AbstractArray, B::AbstractArray) at arraymath.jl:38
    •  
  •  +(A::Number, B::AbstractArray) at arraymath.jl:45
    •  
  •  +(A::AbstractArray, B::Number) at arraymath.jl:48
    •  
  •  +{N}(index1::CartesianIndex{N}, index2::CartesianIndex{N}) at multidimensional.jl:101
    •  
  •  +{N}(index::CartesianIndex{N}, i::Integer) at multidimensional.jl:111
    •  
  •  +(J1::UniformScaling, J2::UniformScaling) at linalg/uniformscaling.jl:58
    •  
  •  +(J::UniformScaling, B::BitArray{2}) at linalg/uniformscaling.jl:60
    •  
  •  +(J::UniformScaling, A::AbstractArray{T,2} where T) at linalg/uniformscaling.jl:61
    •  
  •  +{T}(a::Base.Pkg.Resolve.VersionWeights.HierarchicalValue{T}, b::Base.Pkg.Resolve.VersionWeights.HierarchicalValue{T}) at pkg/resolve/versionweight.jl:23
    •  
  •  +{P<:Base.Dates.Period}(x::P, y::P) at dates/periods.jl:70
    •  
  •  +(x::Base.Dates.Period, y::Base.Dates.Period) at dates/periods.jl:346
    •  
  •  +(y::Base.Dates.Period, x::Base.Dates.CompoundPeriod) at dates/periods.jl:348
    •  
  •  +(x::Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/periods.jl:357
    •  
  •  +(x::Union{Base.Dates.CompoundPeriod, Base.Dates.Period}, Y::Union{Base.ReshapedArray{#s268,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s268,N}, SubArray{#s268,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s268<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/periods.jl:362
    •  
  •  +(x::Base.Dates.TimeType) at dates/arithmetic.jl:8
    •  
  •  +(a::Base.Dates.TimeType, b::Base.Dates.Period, c::Base.Dates.Period) at dates/periods.jl:378
    •  
  •  +(a::Base.Dates.TimeType, b::Base.Dates.Period, c::Base.Dates.Period, d::Base.Dates.Period...) at dates/periods.jl:379
    •  
  •  +(x::Base.Dates.TimeType, y::Base.Dates.CompoundPeriod) at dates/periods.jl:382
    •  
  •  +(x::Base.Dates.Instant) at dates/arithmetic.jl:4
    •  
  •  +(y::Base.Dates.Period, x::Base.Dates.TimeType) at dates/arithmetic.jl:83
    •  
  •  +(x::AbstractArray{#s268,N} where N where #s268<:Base.Dates.TimeType, y::Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/arithmetic.jl:85
    •  
  •  +(x::Base.Dates.Period, r::Range{#s268} where #s268<:Base.Dates.TimeType) at dates/ranges.jl:46
    •  
  •  +(y::Union{Base.Dates.CompoundPeriod, Base.Dates.Period}, x::AbstractArray{#s268,N} where N where #s268<:Base.Dates.TimeType) at dates/arithmetic.jl:87
    •  
  •  +(y::Base.Dates.TimeType, x::Union{Base.ReshapedArray{#s268,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{#s268,N}, SubArray{#s268,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N where #s268<:Union{Base.Dates.CompoundPeriod, Base.Dates.Period}) at dates/arithmetic.jl:88
    •  
  •  +(J::UniformScaling, x::Number) at deprecated.jl:56
    •  
  •  +(x::Number, J::UniformScaling) at deprecated.jl:56
    •  
  •  +(a, b, c, xs...) at operators.jl:424
    •

Following the third link, we get the following code snippet:

+(x::Bool) = int(x)
-(x::Bool) = -int(x)
+(x::Bool, y::Bool) = int(x) + int(y)
-(x::Bool, y::Bool) = int(x) - int(y)
*(x::Bool, y::Bool) = x & y

Therefore:





In [6]:



    


+(true), +(false),-(true),-(false)



    


















    
Out[6]:








(1, 0, -1, 0)

















In [7]:



    


x, y = BitArray([0,1,0,1,0,1]), BitArray([0,1,1,1,1,0])



    


















    
Out[7]:








(Bool[false, true, false, true, false, true], Bool[false, true, true, true, true, false])

The above command is equivalent to

x = bitpack([0,1,0,1,0,1]); y = bitpack([0,1,1,1,1,0])

except that only the last result would be displayed





In [8]:



    


+x,-(x)



    


















    
Out[8]:








(Bool[false, true, false, true, false, true], [0, -1, 0, -1, 0, -1])

















In [9]:



    


x+y, +(x,y)



    


















    
Out[9]:








([0, 2, 1, 2, 1, 1], [0, 2, 1, 2, 1, 1])

















In [10]:



    


c1=x+y



    


















    
Out[10]:








6-element Array{Int64,1}:
 0
 2
 1
 2
 1
 1

















In [11]:



    


c2=+(x,y)



    


















    
Out[11]:








6-element Array{Int64,1}:
 0
 2
 1
 2
 1
 1

Manipulating dates

We see that one of the + methods is adding days to time:

 +(x::Date,y::Base.Dates.Day) at dates/arithmetic.jl:77

Therefore, the 135-th day from today is:





In [12]:



    


Dates.today()



    


















    
Out[12]:








2018-04-06

















In [13]:



    


dd=Dates.today()+Dates.Day(135)



    


















    
Out[13]:








2018-08-19

















In [14]:



    


typeof(dd)



    


















    
Out[14]:








Date

More information about the two types can be obtained by methods(Dates.Date) and methods(Dates.Day), respectively.

Adding tridiagonal matrices

In the above output of methods(+), we see that we can add tridiagonal matrices:

+(A::Tridiagonal{T}, B::Tridiagonal{T}) at linalg/tridiag.jl:624

Following the link, we see that the method separately adds lower, main and upper diagonals, denoted by dl, d and du, respectively:

624: +(A::Tridiagonal, B::Tridiagonal) = Tridiagonal(A.dl+B.dl, A.d+B.d, A.du+B.du)

Let us see how exactly is the type Tridiagonal defined:





In [15]:



    


methods(Tridiagonal)



    


















    
Out[15]:






6 methods for generic function Type:

This output seems confusing, but from the second line we conclude that we can define three diagonals, lower, main and upper diagonal, denoted as above. We also know that that the lower and upper diagonals are of size $n-1$. Let us try it out:





In [16]:



    


T1 = Tridiagonal(rand(6),rand(7),rand(6))



    


















    
Out[16]:








7×7 Tridiagonal{Float64}:
 0.160455  0.046458   ⋅         ⋅         ⋅         ⋅          ⋅      
 0.606172  0.371286  0.511497   ⋅         ⋅         ⋅          ⋅      
  ⋅        0.505555  0.306689  0.954388   ⋅         ⋅          ⋅      
  ⋅         ⋅        0.705459  0.170287  0.367153   ⋅          ⋅      
  ⋅         ⋅         ⋅        0.792429  0.736414  0.0536385   ⋅      
  ⋅         ⋅         ⋅         ⋅        0.455494  0.0364083  0.742944
  ⋅         ⋅         ⋅         ⋅         ⋅        0.171218   0.797836

















In [17]:



    


full(T1)



    


















    
Out[17]:








7×7 Array{Float64,2}:
 0.160455  0.046458  0.0       0.0       0.0       0.0        0.0     
 0.606172  0.371286  0.511497  0.0       0.0       0.0        0.0     
 0.0       0.505555  0.306689  0.954388  0.0       0.0        0.0     
 0.0       0.0       0.705459  0.170287  0.367153  0.0        0.0     
 0.0       0.0       0.0       0.792429  0.736414  0.0536385  0.0     
 0.0       0.0       0.0       0.0       0.455494  0.0364083  0.742944
 0.0       0.0       0.0       0.0       0.0       0.171218   0.797836

















In [18]:



    


T2 = Tridiagonal(rand(-5:5,6),randn(7),rand(-9:0,6))



    


















    
Out[18]:








7×7 Tridiagonal{Float64}:
 -0.24333  -8.0         ⋅          ⋅          ⋅          ⋅          ⋅      
  3.0      -0.783362  -9.0         ⋅          ⋅          ⋅          ⋅      
   ⋅        1.0        0.715596   0.0         ⋅          ⋅          ⋅      
   ⋅         ⋅        -5.0       -0.111861  -3.0         ⋅          ⋅      
   ⋅         ⋅          ⋅         5.0       -0.478957  -3.0         ⋅      
   ⋅         ⋅          ⋅          ⋅        -4.0       -0.855542  -6.0     
   ⋅         ⋅          ⋅          ⋅          ⋅         4.0       -0.496279

















In [19]:



    


T3=T1+T2



    


















    
Out[19]:








7×7 Tridiagonal{Float64}:
 -0.0828749  -7.95354     ⋅        ⋅           ⋅          ⋅          ⋅      
  3.60617    -0.412076  -8.4885    ⋅           ⋅          ⋅          ⋅      
   ⋅          1.50556    1.02228  0.954388     ⋅          ⋅          ⋅      
   ⋅           ⋅        -4.29454  0.0584264  -2.63285     ⋅          ⋅      
   ⋅           ⋅          ⋅       5.79243     0.257457  -2.94636     ⋅      
   ⋅           ⋅          ⋅        ⋅         -3.54451   -0.819133  -5.25706 
   ⋅           ⋅          ⋅        ⋅           ⋅         4.17122    0.301557

















In [20]:



    


@which T1 + T2



    


















    
Out[20]:






+(A::Tridiagonal, B::Tridiagonal) at linalg/tridiag.jl:624

This worked as expected, the result is again a Tridiagonal. We can access each diagonal by:





In [21]:



    


println(T3.dl, T3.d, T3.du)



    


















    






[3.60617, 1.50556, -4.29454, 5.79243, -3.54451, 4.17122][-0.0828749, -0.412076, 1.02228, 0.0584264, 0.257457, -0.819133, 0.301557][-7.95354, -8.4885, 0.954388, -2.63285, -2.94636, -5.25706]

@which

Let us take a closer look at what happens. The @which command gives the link to the part of the code which is actually invoked. The argument should be only function, without assignment, that is

@which T1=Tridiagonal(rand(6),rand(7),rand(6))

throws an error.





In [22]:



    


@which Tridiagonal(rand(6),rand(7),rand(6))



    


















    
Out[22]:






(::Type{Tridiagonal}){T}(dl::Array{T,1}, d::Array{T,1}, du::Array{T,1}) at linalg/tridiag.jl:436

In the code, we see that there is a type definition in the struct block:

## Tridiagonal matrices ##
struct Tridiagonal{T} <: AbstractMatrix{T}
    dl::Vector{T}    # sub-diagonal
    d::Vector{T}     # diagonal
    du::Vector{T}    # sup-diagonal
    du2::Vector{T}   # supsup-diagonal for pivoting
end

The Tridiagonal structure (or type) consists of four vectors. In our case, we actually called the function Tridiagonal() with three vector arguments. The function creates the type of the same name, setting the fourth reqired vector du2 to zeros(T,n-2).

The next function with the same name is invoked when the input vectors have different types, in which case the types arer promoted to a most general one, if possible.





In [23]:



    


T4 = Tridiagonal([1,2,3], [2.0,3.0,pi,4.0],rand(3)+im*rand(3))



    


















    
Out[23]:








4×4 Tridiagonal{Complex{Float64}}:
 2.0+0.0im  0.811235+0.143393im           ⋅                    ⋅         
 1.0+0.0im       3.0+0.0im       0.937443+0.287608im           ⋅         
     ⋅           2.0+0.0im        3.14159+0.0im       0.183007+0.126129im
     ⋅               ⋅                3.0+0.0im            4.0+0.0im

size() and full()

For each matrix type we need to define the function which returns the size of a matrix, and the function which converts the matrix of a given type to a full matrix. These function are listed after the second Tridiagonal() function.





In [24]:



    


size(T4)



    


















    
Out[24]:








(4, 4)

















In [25]:



    


T4 = full(T4)



    


















    
Out[25]:








4×4 Array{Complex{Float64},2}:
 2.0+0.0im  0.811235+0.143393im       0.0+0.0im            0.0+0.0im     
 1.0+0.0im       3.0+0.0im       0.937443+0.287608im       0.0+0.0im     
 0.0+0.0im       2.0+0.0im        3.14159+0.0im       0.183007+0.126129im
 0.0+0.0im       0.0+0.0im            3.0+0.0im            4.0+0.0im

sizeof()

Of course, using special types can leasd to much more efficient programs. For example, for Tridiagonal type, onlt four diagonals are stored, in comparison to storing full matrix when $n^2$ elements are stored. The storage used is obtained by the sizeof() function.





In [26]:



    


T1



    


















    
Out[26]:








7×7 Tridiagonal{Float64}:
 0.160455  0.046458   ⋅         ⋅         ⋅         ⋅          ⋅      
 0.606172  0.371286  0.511497   ⋅         ⋅         ⋅          ⋅      
  ⋅        0.505555  0.306689  0.954388   ⋅         ⋅          ⋅      
  ⋅         ⋅        0.705459  0.170287  0.367153   ⋅          ⋅      
  ⋅         ⋅         ⋅        0.792429  0.736414  0.0536385   ⋅      
  ⋅         ⋅         ⋅         ⋅        0.455494  0.0364083  0.742944
  ⋅         ⋅         ⋅         ⋅         ⋅        0.171218   0.797836

















In [27]:



    


T1f=full(T1)



    


















    
Out[27]:








7×7 Array{Float64,2}:
 0.160455  0.046458  0.0       0.0       0.0       0.0        0.0     
 0.606172  0.371286  0.511497  0.0       0.0       0.0        0.0     
 0.0       0.505555  0.306689  0.954388  0.0       0.0        0.0     
 0.0       0.0       0.705459  0.170287  0.367153  0.0        0.0     
 0.0       0.0       0.0       0.792429  0.736414  0.0536385  0.0     
 0.0       0.0       0.0       0.0       0.455494  0.0364083  0.742944
 0.0       0.0       0.0       0.0       0.0       0.171218   0.797836

















In [28]:



    


sizeof(T1f)  #   392 =  7 * 7 * 8 bytes



    


















    
Out[28]:








392

















In [29]:



    


# This is not yet implemented for Tridiagonal - only the storage 
# required for 4 vector variables' names is displayed
sizeof(T1)



    


















    
Out[29]:








32

struct is immutable

This means that we can change individual elements of defined parts, but not the parts as a whole (an alternative is to use the type construtor). For example:





In [30]:



    


@show T5 = Tridiagonal([1,2,3],[2,3,4,5],[-1,1,2])
T5.d[2]=123
@show T5
T5.dl = [-1, -1 ,1]



    


















    






T5 = Tridiagonal([1, 2, 3], [2, 3, 4, 5], [-1, 1, 2]) = [2 -1 0 0; 1 3 1 0; 0 2 4 2; 0 0 3 5]
T5 = [2 -1 0 0; 1 123 1 0; 0 2 4 2; 0 0 3 5]










    






type Tridiagonal is immutable

Stacktrace:
 [1] include_string(::String, ::String) at ./loading.jl:522

methodswith()

This is the reverse of methods() - which methods exist for the given type. For example, what can we do with Tridiagonal matrices, or with Dates.Day:





In [31]:



    


methodswith(Tridiagonal)



    


















    
Out[31]:






86-element Array{Method,1}:
















In [32]:



    


methodswith(Dates.Day)



    


















    
Out[32]:






26-element Array{Method,1}:

The "*" operator





In [33]:



    


methods(*)



    


















    
Out[33]:






182 methods for generic function *:
  •  *(x::Bool, z::Complex{Bool}) at complex.jl:236
    •  
  •  *(x::Bool, y::Bool) at bool.jl:91
    •  
  •  *{T<:Unsigned}(x::Bool, y::T) at bool.jl:104
    •  
  •  *(x::Bool, z::Complex) at complex.jl:243
    •  
  •  *(x::Bool, y::Irrational) at irrationals.jl:111
    •  
  •  *{T<:Number}(x::Bool, y::T) at bool.jl:101
    •  
  •  *(a::Float16, b::Float16) at float.jl:372
    •  
  •  *(x::Float32, y::Float32) at float.jl:378
    •  
  •  *(x::Float64, y::Float64) at float.jl:379
    •  
  •  *(z::Complex{Bool}, x::Bool) at complex.jl:237
    •  
  •  *(z::Complex{Bool}, x::Real) at complex.jl:255
    •  
  •  *(this::Base.Grisu.Float, other::Base.Grisu.Float) at grisu/float.jl:138
    •  
  •  *(c::BigInt, x::BigFloat) at mpfr.jl:312
    •  
  •  *(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) at gmp.jl:334
    •  
  •  *(a::BigInt, b::BigInt, c::BigInt, d::BigInt) at gmp.jl:327
    •  
  •  *(a::BigInt, b::BigInt, c::BigInt) at gmp.jl:321
    •  
  •  *(x::BigInt, y::BigInt) at gmp.jl:289
    •  
  •  *(x::BigInt, c::Union{UInt16, UInt32, UInt64, UInt8}) at gmp.jl:368
    •  
  •  *(x::BigInt, c::Union{Int16, Int32, Int64, Int8}) at gmp.jl:374
    •  
  •  *(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat, e::BigFloat) at mpfr.jl:460
    •  
  •  *(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat) at mpfr.jl:453
    •  
  •  *(a::BigFloat, b::BigFloat, c::BigFloat) at mpfr.jl:447
    •  
  •  *(x::BigFloat, c::BigInt) at mpfr.jl:308
    •  
  •  *(x::BigFloat, y::BigFloat) at mpfr.jl:277
    •  
  •  *(x::BigFloat, c::Union{UInt16, UInt32, UInt64, UInt8}) at mpfr.jl:284
    •  
  •  *(x::BigFloat, c::Union{Int16, Int32, Int64, Int8}) at mpfr.jl:292
    •  
  •  *(x::BigFloat, c::Union{Float16, Float32, Float64}) at mpfr.jl:300
    •  
  •  *(B::BitArray{2}, J::UniformScaling) at linalg/uniformscaling.jl:149
    •  
  •  *(z::Complex, w::Complex) at complex.jl:223
    •  
  •  *(z::Complex, x::Bool) at complex.jl:244
    •  
  •  *(x::Real, z::Complex{Bool}) at complex.jl:254
    •  
  •  *(x::Real, z::Complex) at complex.jl:266
    •  
  •  *(z::Complex, x::Real) at complex.jl:267
    •  
  •  *(x::Rational, y::Rational) at rational.jl:252
    •  
  •  *{N}(a::Integer, index::CartesianIndex{N}) at multidimensional.jl:114
    •  
  •  *(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigInt) at gmp.jl:372
    •  
  •  *(c::Union{Int16, Int32, Int64, Int8}, x::BigInt) at gmp.jl:378
    •  
  •  *(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigFloat) at mpfr.jl:288
    •  
  •  *(c::Union{Int16, Int32, Int64, Int8}, x::BigFloat) at mpfr.jl:296
    •  
  •  *(c::Union{Float16, Float32, Float64}, x::BigFloat) at mpfr.jl:304
    •  
  •  *(x::Irrational, y::Irrational) at irrationals.jl:109
    •  
  •  *(y::Real, x::Base.Dates.Period) at dates/periods.jl:88
    •  
  •  *(x::Real, r::Base.Use_StepRangeLen_Instead) at deprecated.jl:1235
    •  
  •  *(x::Number) at operators.jl:400
    •  
  •  *(y::Number, x::Bool) at bool.jl:106
    •  
  •  *{T<:Union{Int128, UInt128}}(x::T, y::T) at int.jl:571
    •  
  •  *{T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}(x::T, y::T) at int.jl:33
    •  
  •  *{T<:Number}(x::T, y::T) at promotion.jl:336
    •  
  •  *(x::Number, y::Number) at promotion.jl:250
    •  
  •  *(x::Real, r::StepRangeLen{#s45,#s44,S} where S where #s44<:Base.TwicePrecision where #s45<:Real) at twiceprecision.jl:226
    •  
  •  *(x::Number, r::StepRangeLen) at range.jl:743
    •  
  •  *(x::Number, r::LinSpace) at range.jl:744
    •  
  •  *(x::Number, r::Range) at range.jl:742
    •  
  •  *(r::StepRangeLen{#s45,#s44,S} where S where #s44<:Base.TwicePrecision where #s45<:Real, x::Real) at twiceprecision.jl:228
    •  
  •  *(r::StepRangeLen, x::Number) at range.jl:747
    •  
  •  *(r::LinSpace, x::Number) at range.jl:748
    •  
  •  *(r::Base.Use_StepRangeLen_Instead, x::Real) at deprecated.jl:1236
    •  
  •  *(r::Range, x::Number) at range.jl:746
    •  
  •  *(x::Base.TwicePrecision, v::Integer) at twiceprecision.jl:470
    •  
  •  *{S<:Number, R}(x::Base.TwicePrecision{R}, v::S) at twiceprecision.jl:488
    •  
  •  *(v::Number, x::Base.TwicePrecision) at twiceprecision.jl:492
    •  
  •  *{T<:Real}(rowvec::RowVector{T,CV} where CV<:(ConjArray{T,1,V} where V<:(AbstractArray{T,1} where T) where T), vec::AbstractArray{T,1}) at linalg/rowvector.jl:171
    •  
  •  *{T<:Real}(rowvec::RowVector{T,V} where V<:(AbstractArray{T,1} where T), vec::AbstractArray{T,1}) at linalg/rowvector.jl:170
    •  
  •  *(rowvec::RowVector{T,CV} where CV<:(ConjArray{T,1,V} where V<:(AbstractArray{T,1} where T) where T) where T, vec::AbstractArray{T,1} where T) at linalg/rowvector.jl:172
    •  
  •  *(::RowVector, ::RowVector) at linalg/rowvector.jl:182
    •  
  •  *(rowvec::RowVector, A::Base.LinAlg.AbstractTriangular) at linalg/triangular.jl:1684
    •  
  •  *(rowvec::RowVector, D::Diagonal) at linalg/diagonal.jl:270
    •  
  •  *(rowvec::RowVector, vec::AbstractArray{T,1} where T) at linalg/rowvector.jl:176
    •  
  •  *(rowvec::RowVector, mat::AbstractArray{T,2} where T) at linalg/rowvector.jl:181
    •  
  •  *{T<:Union{Complex{Float32}, Complex{Float64}, Float32, Float64}, S}(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, x::Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at linalg/matmul.jl:74
    •  
  •  *(A::SymTridiagonal, B::Number) at linalg/tridiag.jl:130
    •  
  •  *(A::Tridiagonal, B::Number) at linalg/tridiag.jl:626
    •  
  •  *(A::UpperTriangular, x::Number) at linalg/triangular.jl:576
    •  
  •  *(A::Base.LinAlg.UnitUpperTriangular, x::Number) at linalg/triangular.jl:579
    •  
  •  *(A::LowerTriangular, x::Number) at linalg/triangular.jl:576
    •  
  •  *(A::Base.LinAlg.UnitLowerTriangular, x::Number) at linalg/triangular.jl:579
    •  
  •  *(A::Tridiagonal, B::UpperTriangular) at linalg/triangular.jl:1430
    •  
  •  *(A::Tridiagonal, B::Base.LinAlg.UnitUpperTriangular) at linalg/triangular.jl:1430
    •  
  •  *(A::Tridiagonal, B::LowerTriangular) at linalg/triangular.jl:1430
    •  
  •  *(A::Tridiagonal, B::Base.LinAlg.UnitLowerTriangular) at linalg/triangular.jl:1430
    •  
  •  *(A::LowerTriangular, B::LowerTriangular) at linalg/triangular.jl:1437
    •  
  •  *(A::Base.LinAlg.UnitLowerTriangular, B::LowerTriangular) at linalg/triangular.jl:1445
    •  
  •  *(A::UpperTriangular, B::UpperTriangular) at linalg/triangular.jl:1453
    •  
  •  *(A::Base.LinAlg.UnitUpperTriangular, B::UpperTriangular) at linalg/triangular.jl:1461
    •  
  •  *(A::Base.LinAlg.AbstractTriangular, B::Base.LinAlg.AbstractTriangular) at linalg/triangular.jl:1578
    •  
  •  *(A::Base.LinAlg.AbstractTriangular, D::Diagonal) at linalg/diagonal.jl:149
    •  
  •  *(A::Base.LinAlg.AbstractTriangular, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) at linalg/bidiag.jl:498
    •  
  •  *(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,1} where T) at linalg/triangular.jl:1602
    •  
  •  *(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) at linalg/triangular.jl:1602
    •  
  •  *(A::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}, b::Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T) at linalg/qr.jl:527
    •  
  •  *(A::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}, B::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T) at linalg/qr.jl:539
    •  
  •  *(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T, Q::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}) at linalg/qr.jl:627
    •  
  •  *{T, S}(Q::Base.LinAlg.HessenbergQ{T,S} where S<:(AbstractArray{T,2} where T), X::Union{Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, Union{Base.ReshapedArray{S,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{S,2}, SubArray{S,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}}) at linalg/hessenberg.jl:101
    •  
  •  *{T, S}(X::Union{Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, Union{Base.ReshapedArray{S,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{S,2}, SubArray{S,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}}, Q::Base.LinAlg.HessenbergQ{T,S} where S<:(AbstractArray{T,2} where T)) at linalg/hessenberg.jl:105
    •  
  •  *(A::Base.LinAlg.LQPackedQ, B::Union{Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}} where T) at linalg/lq.jl:137
    •  
  •  *{TA, TB}(A::Union{Base.ReshapedArray{TA,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{TA,2}, SubArray{TA,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, B::Base.LinAlg.LQPackedQ{TB,S} where S<:(AbstractArray{T,2} where T)) at linalg/lq.jl:171
    •  
  •  *(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) at linalg/symmetric.jl:269
    •  
  •  *(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) at linalg/symmetric.jl:270
    •  
  •  *(A::Symmetric, x::Bool) at linalg/symmetric.jl:274
    •  
  •  *(A::Symmetric, x::Number) at linalg/symmetric.jl:276
    •  
  •  *(A::Hermitian, x::Bool) at linalg/symmetric.jl:274
    •  
  •  *(A::Hermitian, x::Real) at linalg/symmetric.jl:276
    •  
  •  *(D::Diagonal, x::Number) at linalg/diagonal.jl:144
    •  
  •  *(Da::Diagonal, Db::Diagonal) at linalg/diagonal.jl:146
    •  
  •  *(D::Diagonal, B::Base.LinAlg.AbstractTriangular) at linalg/diagonal.jl:150
    •  
  •  *(D::Diagonal, A::SparseMatrixCSC) at sparse/linalg.jl:114
    •  
  •  *(D::Diagonal, V::AbstractArray{T,1} where T) at linalg/diagonal.jl:147
    •  
  •  *(D::Diagonal, A::AbstractArray{T,2} where T) at linalg/diagonal.jl:154
    •  
  •  *(A::Bidiagonal, B::Number) at linalg/bidiag.jl:346
    •  
  •  *(A::Union{Bidiagonal, SymTridiagonal, Tridiagonal}, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) at linalg/bidiag.jl:499
    •  
  •  *{T}(A::Bidiagonal{T}, B::AbstractArray{T,1}) at linalg/bidiag.jl:503
    •  
  •  *{P<:Base.Dates.Period}(X::Union{Base.ReshapedArray{P,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{P,N}, SubArray{P,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N, y::Real) at dates/periods.jl:93
    •  
  •  *(x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv, a::Number) at sparse/sparsevector.jl:1447
    •  
  •  *{TX, TvA, TiA}(X::Union{Base.ReshapedArray{TX,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{TX,2}, SubArray{TX,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, A::SparseMatrixCSC{TvA,TiA}) at sparse/linalg.jl:102
    •  
  •  *{Ta, Tx}(A::Union{Base.ReshapedArray{Ta,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Ta,2}, SubArray{Ta,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, x::AbstractSparseArray{Tx,Ti,1} where Ti) at sparse/sparsevector.jl:1522
    •  
  •  *(A::SparseMatrixCSC, x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) at sparse/sparsevector.jl:1700
    •  
  •  *{Tv, Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) at sparse/linalg.jl:125
    •  
  •  *{TvA, TiA, TvB, TiB}(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) at sparse/linalg.jl:24
    •  
  •  *(A::SparseMatrixCSC, D::Diagonal) at sparse/linalg.jl:118
    •  
  •  *(A::Base.SparseArrays.CHOLMOD.Sparse, B::Base.SparseArrays.CHOLMOD.Sparse) at sparse/cholmod.jl:1286
    •  
  •  *(A::Base.SparseArrays.CHOLMOD.Sparse, B::Base.SparseArrays.CHOLMOD.Dense) at sparse/cholmod.jl:1287
    •  
  •  *(A::Base.SparseArrays.CHOLMOD.Sparse, B::Union{Array{T,1}, Array{T,2}} where T) at sparse/cholmod.jl:1288
    •  
  •  *{Ti}(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}, B::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}) at sparse/cholmod.jl:1712
    •  
  •  *{Ti}(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}, B::Union{SparseMatrixCSC{Complex{Float64},Ti}, SparseVector{Complex{Float64},Ti}}) at sparse/cholmod.jl:1714
    •  
  •  *{Ti}(A::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}, B::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}) at sparse/cholmod.jl:1716
    •  
  •  *{Ti}(A::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}, B::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}) at sparse/cholmod.jl:1719
    •  
  •  *{Ti}(A::Union{SparseMatrixCSC{Complex{Float64},Ti}, SparseVector{Complex{Float64},Ti}}, B::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}) at sparse/cholmod.jl:1721
    •  
  •  *{Ti}(A::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}, B::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}) at sparse/cholmod.jl:1723
    •  
  •  *(x::AbstractArray{#s45,2} where #s45<:Number) at abstractarraymath.jl:96
    •  
  •  *(B::Number, A::SymTridiagonal) at linalg/tridiag.jl:131
    •  
  •  *(B::Number, A::Tridiagonal) at linalg/tridiag.jl:627
    •  
  •  *(x::Number, A::UpperTriangular) at linalg/triangular.jl:586
    •  
  •  *(x::Number, A::Base.LinAlg.UnitUpperTriangular) at linalg/triangular.jl:589
    •  
  •  *(x::Number, A::LowerTriangular) at linalg/triangular.jl:586
    •  
  •  *(x::Number, A::Base.LinAlg.UnitLowerTriangular) at linalg/triangular.jl:589
    •  
  •  *(x::Number, D::Diagonal) at linalg/diagonal.jl:143
    •  
  •  *(B::Number, A::Bidiagonal) at linalg/bidiag.jl:347
    •  
  •  *(a::Number, x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) at sparse/sparsevector.jl:1448
    •  
  •  *(A::Number, B::AbstractArray) at arraymath.jl:45
    •  
  •  *(A::AbstractArray, B::Number) at arraymath.jl:48
    •  
  •  *(s1::AbstractString, ss::AbstractString...) at strings/basic.jl:74
    •  
  •  *(index::CartesianIndex, a::Integer) at multidimensional.jl:115
    •  
  •  *(vec::AbstractArray{T,1} where T, rowvec::RowVector) at linalg/rowvector.jl:183
    •  
  •  *(vec::AbstractArray{T,1} where T, rowvec::AbstractArray{T,1} where T) at linalg/rowvector.jl:184
    •  
  •  *(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) at linalg/triangular.jl:1635
    •  
  •  *(A::AbstractArray{T,2} where T, D::Diagonal) at linalg/diagonal.jl:152
    •  
  •  *{T, S}(A::AbstractArray{T,2}, x::AbstractArray{S,1}) at linalg/matmul.jl:78
    •  
  •  *(a::AbstractArray{T,1} where T, B::AbstractArray{T,2} where T) at linalg/matmul.jl:87
    •  
  •  *{T, S}(A::AbstractArray{T,2}, B::AbstractArray{S,2}) at linalg/matmul.jl:145
    •  
  •  *{TA, TB}(A::Base.LinAlg.LQ{TA,S} where S<:(AbstractArray{T,2} where T), B::Union{Union{Base.ReshapedArray{TB,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{TB,1}, SubArray{TB,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, Union{Base.ReshapedArray{TB,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{TB,2}, SubArray{TB,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}}) at linalg/lq.jl:121
    •  
  •  *{TA, TB}(A::Base.LinAlg.LQ{TA,S} where S<:(AbstractArray{T,2} where T), B::Base.LinAlg.QR{TB,S} where S<:(AbstractArray{T,2} where T)) at linalg/lq.jl:125
    •  
  •  *{TA, TB}(A::Base.LinAlg.QR{TA,S} where S<:(AbstractArray{T,2} where T), B::Base.LinAlg.LQ{TB,S} where S<:(AbstractArray{T,2} where T)) at linalg/lq.jl:129
    •  
  •  *(J1::UniformScaling, J2::UniformScaling) at linalg/uniformscaling.jl:148
    •  
  •  *(J::UniformScaling, B::BitArray{2}) at linalg/uniformscaling.jl:150
    •  
  •  *(A::AbstractArray{T,2} where T, J::UniformScaling) at linalg/uniformscaling.jl:151
    •  
  •  *(J::UniformScaling, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) at linalg/uniformscaling.jl:152
    •  
  •  *(x::Number, J::UniformScaling) at linalg/uniformscaling.jl:153
    •  
  •  *(J::UniformScaling, x::Number) at linalg/uniformscaling.jl:154
    •  
  •  *{T, S}(R::Base.LinAlg.AbstractRotation{T}, A::Union{AbstractArray{S,1}, AbstractArray{S,2}}) at linalg/givens.jl:9
    •  
  •  *{T}(G1::Base.LinAlg.Givens{T}, G2::Base.LinAlg.Givens{T}) at linalg/givens.jl:363
    •  
  •  *(p::Base.DFT.ScaledPlan, x::AbstractArray) at dft.jl:255
    •  
  •  *{T, K, N}(p::Base.DFT.FFTW.cFFTWPlan{T,K,false,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:627
    •  
  •  *{T, K}(p::Base.DFT.FFTW.cFFTWPlan{T,K,true,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N) at fft/FFTW.jl:634
    •  
  •  *{N}(p::Base.DFT.FFTW.rFFTWPlan{Float32,-1,false,N} where N, x::Union{Base.ReshapedArray{Float32,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Float32,N}, SubArray{Float32,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:704
    •  
  •  *{N}(p::Base.DFT.FFTW.rFFTWPlan{Complex{Float32},1,false,N} where N, x::Union{Base.ReshapedArray{Complex{Float32},N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Complex{Float32},N}, SubArray{Complex{Float32},N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:711
    •  
  •  *{N}(p::Base.DFT.FFTW.rFFTWPlan{Float64,-1,false,N} where N, x::Union{Base.ReshapedArray{Float64,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Float64,N}, SubArray{Float64,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:704
    •  
  •  *{N}(p::Base.DFT.FFTW.rFFTWPlan{Complex{Float64},1,false,N} where N, x::Union{Base.ReshapedArray{Complex{Float64},N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Complex{Float64},N}, SubArray{Complex{Float64},N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:711
    •  
  •  *{T, K, N}(p::Base.DFT.FFTW.r2rFFTWPlan{T,K,false,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}) at fft/FFTW.jl:790
    •  
  •  *{T, K}(p::Base.DFT.FFTW.r2rFFTWPlan{T,K,true,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N) at fft/FFTW.jl:797
    •  
  •  *{T}(p::Base.DFT.FFTW.DCTPlan{T,5,false}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N) at fft/dct.jl:97
    •  
  •  *{T}(p::Base.DFT.FFTW.DCTPlan{T,4,false}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N) at fft/dct.jl:100
    •  
  •  *{T, K}(p::Base.DFT.FFTW.DCTPlan{T,K,true}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray} where N) at fft/dct.jl:103
    •  
  •  *{T}(p::Base.DFT.Plan{T}, x::AbstractArray) at dft.jl:214
    •  
  •  *(α::Number, p::Base.DFT.Plan) at dft.jl:257
    •  
  •  *(p::Base.DFT.Plan, α::Number) at dft.jl:258
    •  
  •  *(I::UniformScaling, p::Base.DFT.ScaledPlan) at dft.jl:259
    •  
  •  *(p::Base.DFT.ScaledPlan, I::UniformScaling) at dft.jl:260
    •  
  •  *(I::UniformScaling, p::Base.DFT.Plan) at dft.jl:261
    •  
  •  *(p::Base.DFT.Plan, I::UniformScaling) at dft.jl:262
    •  
  •  *{P<:Base.Dates.Period}(x::P, y::Real) at dates/periods.jl:87
    •  
  •  *(s1::Union{AbstractString, Char}, ss::Union{AbstractString, Char}...) at /home/slap/.julia/v0.6/Compat/src/Compat.jl:929
    •  
  •  *(a, b, c, xs...) at operators.jl:424
    •

We can multiply various types of numbers and matrices. Notice, however, that there is no multiplication specifically defined for Tridiagonal matrices. This would not make much sense, since the product of two tridiagonal matrices is a pentadiagonal matrix, the product of three tridiagonal matrices is septadiagonal matrix, ...

Therefore, two tridiagonal matrices are first converted to full matrices, and then multiplied, as is seen in the source code.





In [34]:



    


T1*T2



    


















    
Out[34]:








7×7 Array{Float64,2}:
 0.10033   -1.32004    -0.418122   0.0        0.0        0.0       0.0     
 0.966359  -4.62873    -2.97555    0.0        0.0        0.0       0.0     
 1.51667   -0.0893441  -9.10247   -0.106759  -2.86316    0.0       0.0     
 0.0        0.705459   -0.346614   1.81672   -0.686713  -1.10146   0.0     
 0.0        0.0        -3.96214    3.59343   -2.94455   -2.25513  -0.321831
 0.0        0.0         0.0        2.27747   -0.363795   1.57414  -0.587157
 0.0        0.0         0.0        0.0       -0.684871   3.04486  -1.42326 

















In [35]:



    


@which T1*T2



    


















    
Out[35]:






*(A::Union{Bidiagonal, SymTridiagonal, Tridiagonal}, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) at linalg/bidiag.jl:499
















In [36]:



    


T1*T2*T1



    


















    
Out[36]:








7×7 Array{Float64,2}:
 -0.78407   -0.696834  -0.803427  …   0.0        0.0         0.0     
 -2.65075   -3.178     -3.28015       0.0        0.0         0.0     
  0.189199  -4.56451   -2.91264      -2.14767   -0.153576    0.0     
  0.427629   0.086695   1.53616      -0.3404    -0.0769365  -0.818322
  0.0       -2.00308    1.31987      -1.87627   -0.29515    -1.9322  
  0.0        0.0        1.60666   …   1.28529   -0.0627332   0.701046
  0.0        0.0        0.0           0.882566  -0.169564    1.12663

The "$\cdot$" operator





In [37]:



    


methods(⋅)



    


















    
Out[37]:






11 methods for generic function dot:
  •  dot(x::BitArray{1}, y::BitArray{1}) at linalg/bitarray.jl:5
    •  
  •  dot(x::Number, y::Number) at linalg/generic.jl:675
    •  
  •  dot{T<:Union{Float32, Float64}}(DX::Union{DenseArray{T,N} where N, Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}}, DY::Union{DenseArray{T,N} where N, Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}}) at linalg/blas.jl:309
    •  
  •  dot{T<:Union{Float32, Float64}, TI<:Integer}(x::Array{T,1}, rx::Union{Range{TI}, UnitRange{TI}}, y::Array{T,1}, ry::Union{Range{TI}, UnitRange{TI}}) at linalg/matmul.jl:45
    •  
  •  dot{T<:Union{Complex{Float32}, Complex{Float64}}, TI<:Integer}(x::Array{T,1}, rx::Union{Range{TI}, UnitRange{TI}}, y::Array{T,1}, ry::Union{Range{TI}, UnitRange{TI}}) at linalg/matmul.jl:58
    •  
  •  dot{Tx<:Number, Ty<:Number}(x::Union{Base.ReshapedArray{Tx,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T}, DenseArray{Tx,1}, SubArray{Tx,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:Union{DenseArray, SubArray{T,N,P,I,true} where I<:Tuple{Union{Base.Slice, UnitRange},Vararg{Any,N} where N} where P where N where T} where N where T, DenseArray}, y::AbstractSparseArray{Ty,Ti,1} where Ti) at sparse/sparsevector.jl:1457
    •  
  •  dot(x::AbstractSparseArray{#s268,Ti,1} where Ti where #s268<:Number, y::AbstractSparseArray{#s267,Ti,1} where Ti where #s267<:Number) at sparse/sparsevector.jl:1502
    •  
  •  dot{Tx<:Number, Ty<:Number}(x::AbstractSparseArray{Tx,Ti,1} where Ti, y::AbstractArray{Ty,1}) at sparse/sparsevector.jl:1469
    •  
  •  dot(x::AbstractArray{T,1} where T, y::AbstractArray{T,1} where T) at linalg/generic.jl:693
    •  
  •  dot(n::Integer, DX::Union{DenseArray{Float64,N} where N, Ptr{Float64}}, incx::Integer, DY::Union{DenseArray{Float64,N} where N, Ptr{Float64}}, incy::Integer) at linalg/blas.jl:266
    •  
  •  dot(n::Integer, DX::Union{DenseArray{Float32,N} where N, Ptr{Float32}}, incx::Integer, DY::Union{DenseArray{Float32,N} where N, Ptr{Float32}}, incy::Integer) at linalg/blas.jl:266
    •

By inspecting the source, we see that the scalar or the dot product of two vectors (1-dimensional arrays) is computed via BLAS function dot for real arguments, and the function dotc for complex arguments.





In [38]:



    


x = rand(1:5,5); y  = rand(-5:0,5); a = x⋅y
z = rand(5); b = x⋅z; c = z⋅x
w = rand(5) + im*rand(5); d = x⋅w; e = z⋅w; f = w⋅z
@show x, y, z, w
@show a, b, c, d, e, f



    


















    






(x, y, z, w) = ([4, 1, 5, 2, 1], [-2, -1, -3, -5, -1], [0.108631, 0.930885, 0.269912, 0.585359, 0.807561], Complex{Float64}[0.0582148+0.900483im, 0.358971+0.671286im, 0.547201+0.892496im, 0.0296462+0.949889im, 0.060725+0.681899im])
(a, b, c, d, e, f) = (-35, 4.693243973344474, 4.693243973344474, 3.447853231329483 + 11.317373860567262im, 0.5545736165566276 + 2.0703059930893346im, 0.5545736165566276 - 2.0703059930893346im)










    
Out[38]:








(-35, 4.693243973344474, 4.693243973344474, 3.447853231329483 + 11.317373860567262im, 0.5545736165566276 + 2.0703059930893346im, 0.5545736165566276 - 2.0703059930893346im)

whos()

The command whos() reveals the content of the specified package or module. It can be invoked either with the package name, or with the package name and a regular expression.





In [39]:



    


whos(Dates)



    


















    






               @dateformat_str      0 bytes  Base.Dates.#@dateformat_str
                           Apr      8 bytes  Int64
                         April      8 bytes  Int64
                           Aug      8 bytes  Int64
                        August      8 bytes  Int64
                          Date    112 bytes  DataType
                    DateFormat     80 bytes  UnionAll
                    DatePeriod     92 bytes  DataType
                      DateTime    112 bytes  DataType
                         Dates  22540 KB     Module
                      Datetime      0 bytes  Base.Dates.#Datetime
                           Day    112 bytes  DataType
                           Dec      8 bytes  Int64
                      December      8 bytes  Int64
                           Feb      8 bytes  Int64
                      February      8 bytes  Int64
                           Fri      8 bytes  Int64
                        Friday      8 bytes  Int64
                          Hour    112 bytes  DataType
                 ISODateFormat   6503 bytes  DateFormat{Symbol("yyyy-mm-dd"),Tu…
             ISODateTimeFormat   6599 bytes  DateFormat{Symbol("yyyy-mm-dd\\THH…
                           Jan      8 bytes  Int64
                       January      8 bytes  Int64
                           Jul      8 bytes  Int64
                          July      8 bytes  Int64
                           Jun      8 bytes  Int64
                          June      8 bytes  Int64
                           Mar      8 bytes  Int64
                         March      8 bytes  Int64
                           May      8 bytes  Int64
                   Microsecond    112 bytes  DataType
                   Millisecond    112 bytes  DataType
                        Minute    112 bytes  DataType
                           Mon      8 bytes  Int64
                        Monday      8 bytes  Int64
                         Month    112 bytes  DataType
                    Nanosecond    112 bytes  DataType
                           Nov      8 bytes  Int64
                      November      8 bytes  Int64
                           Oct      8 bytes  Int64
                       October      8 bytes  Int64
                        Period     92 bytes  DataType
                 RFC1123Format   6625 bytes  DateFormat{Symbol("e, dd u yyyy HH…
                           Sat      8 bytes  Int64
                      Saturday      8 bytes  Int64
                        Second    112 bytes  DataType
                           Sep      8 bytes  Int64
                     September      8 bytes  Int64
                           Sun      8 bytes  Int64
                        Sunday      8 bytes  Int64
                           Thu      8 bytes  Int64
                      Thursday      8 bytes  Int64
                          Time    112 bytes  DataType
                    TimePeriod     92 bytes  DataType
                      TimeType     92 bytes  DataType
                      TimeZone     92 bytes  DataType
                           Tue      8 bytes  Int64
                       Tuesday      8 bytes  Int64
                           UTC     92 bytes  DataType
                           Wed      8 bytes  Int64
                     Wednesday      8 bytes  Int64
                          Week    112 bytes  DataType
                          Year    112 bytes  DataType
                        adjust      0 bytes  Base.Dates.#adjust
                  canonicalize      0 bytes  Base.Dates.#canonicalize
               datetime2julian      0 bytes  Base.Dates.#datetime2julian
                 datetime2rata      0 bytes  Base.Dates.#datetime2rata
                 datetime2unix      0 bytes  Base.Dates.#datetime2unix
                           day      0 bytes  Base.Dates.#day
                       dayabbr      0 bytes  Base.Dates.#dayabbr
                       dayname      0 bytes  Base.Dates.#dayname
                    dayofmonth      0 bytes  Base.Dates.#dayofmonth
                  dayofquarter      0 bytes  Base.Dates.#dayofquarter
                     dayofweek      0 bytes  Base.Dates.#dayofweek
              dayofweekofmonth      0 bytes  Base.Dates.#dayofweekofmonth
                     dayofyear      0 bytes  Base.Dates.#dayofyear
                   daysinmonth      0 bytes  Base.Dates.#daysinmonth
                    daysinyear      0 bytes  Base.Dates.#daysinyear
             daysofweekinmonth      0 bytes  Base.Dates.#daysofweekinmonth
               firstdayofmonth      0 bytes  Base.Dates.#firstdayofmonth
             firstdayofquarter      0 bytes  Base.Dates.#firstdayofquarter
                firstdayofweek      0 bytes  Base.Dates.#firstdayofweek
                firstdayofyear      0 bytes  Base.Dates.#firstdayofyear
                          hour      0 bytes  Base.Dates.#hour
                    isleapyear      0 bytes  Base.Dates.#isleapyear
               julian2datetime      0 bytes  Base.Dates.#julian2datetime
                lastdayofmonth      0 bytes  Base.Dates.#lastdayofmonth
              lastdayofquarter      0 bytes  Base.Dates.#lastdayofquarter
                 lastdayofweek      0 bytes  Base.Dates.#lastdayofweek
                 lastdayofyear      0 bytes  Base.Dates.#lastdayofyear
                   microsecond      0 bytes  Base.Dates.#microsecond
                   millisecond      0 bytes  Base.Dates.#millisecond
                        minute      0 bytes  Base.Dates.#minute
                         month      0 bytes  Base.Dates.#month
                     monthabbr      0 bytes  Base.Dates.#monthabbr
                      monthday      0 bytes  Base.Dates.#monthday
                     monthname      0 bytes  Base.Dates.#monthname
                    nanosecond      0 bytes  Base.Dates.#nanosecond
                           now      0 bytes  Base.Dates.#now
                 quarterofyear      0 bytes  Base.Dates.#quarterofyear
                 rata2datetime      0 bytes  Base.Dates.#rata2datetime
                        second      0 bytes  Base.Dates.#second
                         today      0 bytes  Base.Dates.#today
                       tofirst      0 bytes  Base.Dates.#tofirst
                        tolast      0 bytes  Base.Dates.#tolast
                        tonext      0 bytes  Base.Dates.#tonext
                        toprev      0 bytes  Base.Dates.#toprev
                 unix2datetime      0 bytes  Base.Dates.#unix2datetime
                          week      0 bytes  Base.Dates.#week
                          year      0 bytes  Base.Dates.#year
                     yearmonth      0 bytes  Base.Dates.#yearmonth
                  yearmonthday      0 bytes  Base.Dates.#yearmonthday

















In [40]:



    


whos(LinAlg)



    


















    






                             /      0 bytes  Base.#/
               ARPACKException    112 bytes  DataType
                     A_ldiv_B!      0 bytes  Base.LinAlg.#A_ldiv_B!
                     A_ldiv_Bc      0 bytes  Base.#A_ldiv_Bc
                     A_ldiv_Bt      0 bytes  Base.#A_ldiv_Bt
                      A_mul_B!      0 bytes  Base.LinAlg.#A_mul_B!
                      A_mul_Bc      0 bytes  Base.#A_mul_Bc
                     A_mul_Bc!      0 bytes  Base.LinAlg.#A_mul_Bc!
                      A_mul_Bt      0 bytes  Base.#A_mul_Bt
                     A_mul_Bt!      0 bytes  Base.LinAlg.#A_mul_Bt!
                     A_rdiv_Bc      0 bytes  Base.#A_rdiv_Bc
                     A_rdiv_Bt      0 bytes  Base.#A_rdiv_Bt
                     Ac_ldiv_B      0 bytes  Base.#Ac_ldiv_B
                    Ac_ldiv_B!      0 bytes  Base.LinAlg.#Ac_ldiv_B!
                    Ac_ldiv_Bc      0 bytes  Base.#Ac_ldiv_Bc
                      Ac_mul_B      0 bytes  Base.#Ac_mul_B
                     Ac_mul_B!      0 bytes  Base.LinAlg.#Ac_mul_B!
                     Ac_mul_Bc      0 bytes  Base.#Ac_mul_Bc
                    Ac_mul_Bc!      0 bytes  Base.LinAlg.#Ac_mul_Bc!
                     Ac_rdiv_B      0 bytes  Base.#Ac_rdiv_B
                    Ac_rdiv_Bc      0 bytes  Base.#Ac_rdiv_Bc
                     At_ldiv_B      0 bytes  Base.#At_ldiv_B
                    At_ldiv_B!      0 bytes  Base.LinAlg.#At_ldiv_B!
                    At_ldiv_Bt      0 bytes  Base.#At_ldiv_Bt
                      At_mul_B      0 bytes  Base.#At_mul_B
                     At_mul_B!      0 bytes  Base.LinAlg.#At_mul_B!
                     At_mul_Bt      0 bytes  Base.#At_mul_Bt
                    At_mul_Bt!      0 bytes  Base.LinAlg.#At_mul_Bt!
                     At_rdiv_B      0 bytes  Base.#At_rdiv_B
                    At_rdiv_Bt      0 bytes  Base.#At_rdiv_Bt
                          BLAS  22541 KB     Module
                    Bidiagonal     40 bytes  UnionAll
                  BunchKaufman    120 bytes  UnionAll
                      Cholesky    120 bytes  UnionAll
               CholeskyPivoted    120 bytes  UnionAll
                     ConjArray    200 bytes  UnionAll
                    ConjMatrix    120 bytes  UnionAll
                    ConjVector    120 bytes  UnionAll
                      Diagonal     40 bytes  UnionAll
                         Eigen    240 bytes  UnionAll
                 Factorization     40 bytes  UnionAll
              GeneralizedEigen    240 bytes  UnionAll
                GeneralizedSVD     80 bytes  UnionAll
              GeneralizedSchur    120 bytes  UnionAll
                     Hermitian    120 bytes  UnionAll
                    Hessenberg    120 bytes  UnionAll
                             I      8 bytes  UniformScaling{Int64}
                        LAPACK  23277 KB     Module
               LAPACKException    112 bytes  DataType
                          LDLt    120 bytes  UnionAll
                            LQ    120 bytes  UnionAll
                            LU    120 bytes  UnionAll
                        LinAlg  24726 KB     Module
               LowerTriangular    120 bytes  UnionAll
               PosDefException    112 bytes  DataType
                            QR    120 bytes  UnionAll
                     QRPivoted    120 bytes  UnionAll
        RankDeficientException    112 bytes  DataType
                     RowVector    120 bytes  UnionAll
                           SVD    200 bytes  UnionAll
                         Schur    120 bytes  UnionAll
             SingularException    112 bytes  DataType
                SymTridiagonal     40 bytes  UnionAll
                     Symmetric    120 bytes  UnionAll
                   Tridiagonal     40 bytes  UnionAll
                UniformScaling     40 bytes  UnionAll
               UpperTriangular    120 bytes  UnionAll
                             \      0 bytes  Base.#\
                         axpy!      0 bytes  Base.LinAlg.#axpy!
                        bkfact      0 bytes  Base.LinAlg.#bkfact
                       bkfact!      0 bytes  Base.LinAlg.#bkfact!
                          chol      0 bytes  Base.LinAlg.#chol
                      cholfact      0 bytes  Base.LinAlg.#cholfact
                     cholfact!      0 bytes  Base.LinAlg.#cholfact!
                          cond      0 bytes  Base.LinAlg.#cond
                     condskeel      0 bytes  Base.LinAlg.#condskeel
                         copy!      0 bytes  Base.#copy!
               copy_transpose!      0 bytes  Base.LinAlg.#copy_transpose!
                         cross      0 bytes  Base.LinAlg.#cross
                    ctranspose      0 bytes  Base.#ctranspose
                   ctranspose!      0 bytes  Base.LinAlg.#ctranspose!
                           det      0 bytes  Base.LinAlg.#det
                          diag      0 bytes  Base.LinAlg.#diag
                       diagind      0 bytes  Base.LinAlg.#diagind
                         diagm      0 bytes  Base.LinAlg.#diagm
                          diff      0 bytes  Base.LinAlg.#diff
                           dot      0 bytes  Base.LinAlg.#dot
                           eig      0 bytes  Base.LinAlg.#eig
                       eigfact      0 bytes  Base.LinAlg.#eigfact
                      eigfact!      0 bytes  Base.LinAlg.#eigfact!
                        eigmax      0 bytes  Base.LinAlg.#eigmax
                        eigmin      0 bytes  Base.LinAlg.#eigmin
                          eigs      0 bytes  Base.LinAlg.#eigs
                       eigvals      0 bytes  Base.LinAlg.#eigvals
                      eigvals!      0 bytes  Base.LinAlg.#eigvals!
                       eigvecs      0 bytes  Base.LinAlg.#eigvecs
                          expm      0 bytes  Base.LinAlg.#expm
                           eye      0 bytes  Base.#eye
                     factorize      0 bytes  Base.LinAlg.#factorize
                        givens      0 bytes  Base.LinAlg.#givens
                      gradient      0 bytes  Base.LinAlg.#gradient
                      hessfact      0 bytes  Base.LinAlg.#hessfact
                     hessfact!      0 bytes  Base.LinAlg.#hessfact!
                        isdiag      0 bytes  Base.LinAlg.#isdiag
                   ishermitian      0 bytes  Base.LinAlg.#ishermitian
                      isposdef      0 bytes  Base.LinAlg.#isposdef
                     isposdef!      0 bytes  Base.LinAlg.#isposdef!
                   issymmetric      0 bytes  Base.LinAlg.#issymmetric
                        istril      0 bytes  Base.LinAlg.#istril
                        istriu      0 bytes  Base.LinAlg.#istriu
                          kron      0 bytes  Base.#kron
                      ldltfact      0 bytes  Base.LinAlg.#ldltfact
                     ldltfact!      0 bytes  Base.LinAlg.#ldltfact!
                        linreg      0 bytes  Base.LinAlg.#linreg
                     logabsdet      0 bytes  Base.LinAlg.#logabsdet
                        logdet      0 bytes  Base.LinAlg.#logdet
                          logm      0 bytes  Base.LinAlg.#logm
                            lq      0 bytes  Base.LinAlg.#lq
                        lqfact      0 bytes  Base.LinAlg.#lqfact
                       lqfact!      0 bytes  Base.LinAlg.#lqfact!
                            lu      0 bytes  Base.LinAlg.#lu
                        lufact      0 bytes  Base.LinAlg.#lufact
                       lufact!      0 bytes  Base.LinAlg.#lufact!
                          lyap      0 bytes  Base.LinAlg.#lyap
                          norm      0 bytes  Base.LinAlg.#norm
                     normalize      0 bytes  Base.LinAlg.#normalize
                    normalize!      0 bytes  Base.LinAlg.#normalize!
                     nullspace      0 bytes  Base.LinAlg.#nullspace
                      ordschur      0 bytes  Base.LinAlg.#ordschur
                     ordschur!      0 bytes  Base.LinAlg.#ordschur!
                     peakflops      0 bytes  Base.LinAlg.#peakflops
                          pinv      0 bytes  Base.LinAlg.#pinv
                            qr      0 bytes  Base.LinAlg.#qr
                        qrfact      0 bytes  Base.LinAlg.#qrfact
                       qrfact!      0 bytes  Base.LinAlg.#qrfact!
                          rank      0 bytes  Base.LinAlg.#rank
                        scale!      0 bytes  Base.LinAlg.#scale!
                         schur      0 bytes  Base.LinAlg.#schur
                     schurfact      0 bytes  Base.LinAlg.#schurfact
                    schurfact!      0 bytes  Base.LinAlg.#schurfact!
                         sqrtm      0 bytes  Base.LinAlg.#sqrtm
                           svd      0 bytes  Base.LinAlg.#svd
                       svdfact      0 bytes  Base.LinAlg.#svdfact
                      svdfact!      0 bytes  Base.LinAlg.#svdfact!
                          svds      0 bytes  Base.LinAlg.#svds
                       svdvals      0 bytes  Base.LinAlg.#svdvals
                      svdvals!      0 bytes  Base.LinAlg.#svdvals!
                     sylvester      0 bytes  Base.LinAlg.#sylvester
                         trace      0 bytes  Base.LinAlg.#trace
                     transpose      0 bytes  Base.#transpose
                    transpose!      0 bytes  Base.LinAlg.#transpose!
                transpose_type      0 bytes  Base.LinAlg.#transpose_type
                          tril      0 bytes  Base.LinAlg.#tril
                         tril!      0 bytes  Base.LinAlg.#tril!
                          triu      0 bytes  Base.LinAlg.#triu
                         triu!      0 bytes  Base.LinAlg.#triu!
                        vecdot      0 bytes  Base.LinAlg.#vecdot
                       vecnorm      0 bytes  Base.LinAlg.#vecnorm

















In [41]:



    


# Now with a regular expression - we are looking for 
# 'eigenvalue' related stuff. 
whos(Base, Regex("eig"))



    


















    






                           eig      0 bytes  Base.LinAlg.#eig
                       eigfact      0 bytes  Base.LinAlg.#eigfact
                      eigfact!      0 bytes  Base.LinAlg.#eigfact!
                        eigmax      0 bytes  Base.LinAlg.#eigmax
                        eigmin      0 bytes  Base.LinAlg.#eigmin
                          eigs      0 bytes  Base.LinAlg.#eigs
                       eigvals      0 bytes  Base.LinAlg.#eigvals
                      eigvals!      0 bytes  Base.LinAlg.#eigvals!
                       eigvecs      0 bytes  Base.LinAlg.#eigvecs

Funally, let us list all we have in Julia's Base module. It is a long list! Notice that Dates and LinAlg are modules themselves.





In [42]:



    


whos(Base)



    


















    






                             !      0 bytes  Base.#!
                            !=      0 bytes  Base.#!=
                           !==      0 bytes  Base.#!==
                             $      0 bytes  Base.#$
                             %      0 bytes  Base.#rem
                             &      0 bytes  Base.#&
                             *      0 bytes  Base.#*
                             +      0 bytes  Base.#+
                             -      0 bytes  Base.#-
                           .!=      0 bytes  Base.##711#712
                            .%      0 bytes  Base.##725#726
                            .*      0 bytes  Base.##719#720
                            .+      0 bytes  Base.##715#716
                            .-      0 bytes  Base.##717#718
                            ./      0 bytes  Base.##721#722
                           .//      0 bytes  Base.##745#746
                            .<      0 bytes  Base.##727#728
                           .<<      0 bytes  Base.##749#750
                           .<=      0 bytes  Base.##729#730
                           .==      0 bytes  Base.##733#734
                            .>      0 bytes  Base.##735#736
                           .>=      0 bytes  Base.##737#738
                           .>>      0 bytes  Base.##747#748
                            .\      0 bytes  Base.##741#742
                            .^      0 bytes  Base.##743#744
                            .÷      0 bytes  Base.##723#724
                            .≠      0 bytes  Base.##713#714
                            .≤      0 bytes  Base.##731#732
                            .≥      0 bytes  Base.##739#740
                             /      0 bytes  Base.#/
                            //      0 bytes  Base.#//
                             :      0 bytes  Colon
                             <      0 bytes  Base.#<
                            <:      0 bytes  Core.#issubtype
                            <<      0 bytes  Base.#<<
                            <=      0 bytes  Base.#<=
                            ==      0 bytes  Base.#==
                            =>     80 bytes  UnionAll
                             >      0 bytes  Base.#>
                            >:      0 bytes  Base.#>:
                            >=      0 bytes  Base.#>=
                            >>      0 bytes  Base.#>>
                           >>>      0 bytes  Base.#>>>
                     @MIME_str      0 bytes  Base.#@MIME_str
                      @__DIR__      0 bytes  Base.#@__DIR__
                     @__FILE__      0 bytes  Base.#@__FILE__
                      @__dot__      0 bytes  Base.Broadcast.#@__dot__
                    @allocated      0 bytes  Base.#@allocated
                       @assert      0 bytes  Base.#@assert
                        @async      0 bytes  Base.#@async
                        @b_str      0 bytes  Base.#@b_str
                      @big_str      0 bytes  Base.#@big_str
                  @boundscheck      0 bytes  Base.#@boundscheck
                          @cmd      0 bytes  Base.#@cmd
                    @code_llvm      0 bytes  Base.#@code_llvm
                 @code_lowered      0 bytes  Base.#@code_lowered
                  @code_native      0 bytes  Base.#@code_native
                   @code_typed      0 bytes  Base.#@code_typed
                @code_warntype      0 bytes  Base.#@code_warntype
               @dateformat_str      0 bytes  Base.Dates.#@dateformat_str
                    @deprecate      0 bytes  Base.#@deprecate
                          @doc      0 bytes  Core.#@doc
                      @doc_str      0 bytes  Core.#@doc_str
                         @edit      0 bytes  Base.#@edit
                      @elapsed      0 bytes  Base.#@elapsed
                         @enum      0 bytes  Base.Enums.#@enum
                         @eval      0 bytes  Base.#@eval
                     @evalpoly      0 bytes  Base.Math.#@evalpoly
                   @everywhere      0 bytes  Base.Distributed.#@everywhere
                     @fastmath      0 bytes  Base.FastMath.#@fastmath
                        @fetch      0 bytes  Base.Distributed.#@fetch
                    @fetchfrom      0 bytes  Base.Distributed.#@fetchfrom
                  @functionloc      0 bytes  Base.#@functionloc
                    @generated      0 bytes  Base.#@generated
                       @gensym      0 bytes  Base.#@gensym
                         @goto      0 bytes  Base.#@goto
                     @html_str      0 bytes  Base.Docs.#@html_str
                     @inbounds      0 bytes  Base.#@inbounds
                       @inline      0 bytes  Base.#@inline
                   @int128_str      0 bytes  Base.#@int128_str
                       @ip_str      0 bytes  Base.#@ip_str
                        @label      0 bytes  Base.#@label
                         @less      0 bytes  Base.#@less
                  @macroexpand      0 bytes  Base.#@macroexpand
                     @noinline      0 bytes  Base.#@noinline
                     @parallel      0 bytes  Base.Distributed.#@parallel
                        @polly      0 bytes  Base.#@polly
                       @printf      0 bytes  Base.Printf.#@printf
                      @profile      0 bytes  Base.Profile.#@profile
                        @r_str      0 bytes  Base.#@r_str
                      @raw_str      0 bytes  Base.#@raw_str
                        @s_str      0 bytes  Base.#@s_str
                     @schedule      0 bytes  Base.#@schedule
                         @show      0 bytes  Base.#@show
                         @simd      0 bytes  Base.SimdLoop.#@simd
                        @spawn      0 bytes  Base.Distributed.#@spawn
                      @spawnat      0 bytes  Base.Distributed.#@spawnat
                      @sprintf      0 bytes  Base.Printf.#@sprintf
                       @static      0 bytes  Base.#@static
                         @sync      0 bytes  Base.#@sync
                         @task      0 bytes  Base.#@task
                     @text_str      0 bytes  Base.Docs.#@text_str
                   @threadcall      0 bytes  Base.#@threadcall
                         @time      0 bytes  Base.#@time
                        @timed      0 bytes  Base.#@timed
                        @timev      0 bytes  Base.#@timev
                  @uint128_str      0 bytes  Base.#@uint128_str
                        @v_str      0 bytes  Base.#@v_str
               @vectorize_1arg      0 bytes  Base.#@vectorize_1arg
               @vectorize_2arg      0 bytes  Base.#@vectorize_2arg
                         @view      0 bytes  Base.#@view
                        @views      0 bytes  Base.#@views
                        @which      0 bytes  Base.#@which
                          ARGS     87 bytes  1-element Array{String,1}
                     A_ldiv_B!      0 bytes  Base.LinAlg.#A_ldiv_B!
                     A_ldiv_Bc      0 bytes  Base.#A_ldiv_Bc
                     A_ldiv_Bt      0 bytes  Base.#A_ldiv_Bt
                      A_mul_B!      0 bytes  Base.LinAlg.#A_mul_B!
                      A_mul_Bc      0 bytes  Base.#A_mul_Bc
                     A_mul_Bc!      0 bytes  Base.LinAlg.#A_mul_Bc!
                      A_mul_Bt      0 bytes  Base.#A_mul_Bt
                     A_mul_Bt!      0 bytes  Base.LinAlg.#A_mul_Bt!
                     A_rdiv_Bc      0 bytes  Base.#A_rdiv_Bc
                     A_rdiv_Bt      0 bytes  Base.#A_rdiv_Bt
               AbstractChannel     92 bytes  DataType
                AbstractMatrix     40 bytes  UnionAll
                   AbstractRNG     92 bytes  DataType
            AbstractSerializer     92 bytes  DataType
                   AbstractSet     40 bytes  UnionAll
           AbstractSparseArray    120 bytes  UnionAll
          AbstractSparseMatrix     80 bytes  UnionAll
          AbstractSparseVector     80 bytes  UnionAll
             AbstractUnitRange     40 bytes  UnionAll
              AbstractVecOrMat     56 bytes  UnionAll
                AbstractVector     40 bytes  UnionAll
                     Ac_ldiv_B      0 bytes  Base.#Ac_ldiv_B
                    Ac_ldiv_B!      0 bytes  Base.LinAlg.#Ac_ldiv_B!
                    Ac_ldiv_Bc      0 bytes  Base.#Ac_ldiv_Bc
                      Ac_mul_B      0 bytes  Base.#Ac_mul_B
                     Ac_mul_B!      0 bytes  Base.LinAlg.#Ac_mul_B!
                     Ac_mul_Bc      0 bytes  Base.#Ac_mul_Bc
                    Ac_mul_Bc!      0 bytes  Base.LinAlg.#Ac_mul_Bc!
                     Ac_rdiv_B      0 bytes  Base.#Ac_rdiv_B
                    Ac_rdiv_Bc      0 bytes  Base.#Ac_rdiv_Bc
                 ArgumentError    112 bytes  DataType
                         Array     80 bytes  UnionAll
                AssertionError    112 bytes  DataType
                   Associative     80 bytes  UnionAll
                     At_ldiv_B      0 bytes  Base.#At_ldiv_B
                    At_ldiv_B!      0 bytes  Base.LinAlg.#At_ldiv_B!
                    At_ldiv_Bt      0 bytes  Base.#At_ldiv_Bt
                      At_mul_B      0 bytes  Base.#At_mul_B
                     At_mul_B!      0 bytes  Base.LinAlg.#At_mul_B!
                     At_mul_Bt      0 bytes  Base.#At_mul_Bt
                    At_mul_Bt!      0 bytes  Base.LinAlg.#At_mul_Bt!
                     At_rdiv_B      0 bytes  Base.#At_rdiv_B
                    At_rdiv_Bt      0 bytes  Base.#At_rdiv_Bt
                          BLAS  22808 KB     Module
                          Base               Module
              Base64DecodePipe    136 bytes  DataType
              Base64EncodePipe    148 bytes  DataType
                    Bidiagonal     40 bytes  UnionAll
                      BigFloat    148 bytes  DataType
                        BigInt    136 bytes  DataType
                      BitArray     40 bytes  UnionAll
                     BitMatrix    152 bytes  DataType
                     BitVector    152 bytes  DataType
                  BufferStream    172 bytes  DataType
                        C_NULL      8 bytes  Ptr{Void}
                   CachingPool    136 bytes  DataType
             CapturedException    124 bytes  DataType
                CartesianIndex     40 bytes  UnionAll
                CartesianRange     80 bytes  UnionAll
                         Cchar     92 bytes  DataType
                       Cdouble     92 bytes  DataType
                        Cfloat     92 bytes  DataType
                       Channel     40 bytes  UnionAll
                          Cint     92 bytes  DataType
                     Cintmax_t     92 bytes  DataType
                         Clong     92 bytes  DataType
                     Clonglong     92 bytes  DataType
                ClusterManager     92 bytes  DataType
                           Cmd    216 bytes  DataType
                   Collections     23 KB     Module
                         Colon     92 bytes  DataType
                       Complex     40 bytes  UnionAll
                    Complex128    132 bytes  DataType
                     Complex32    132 bytes  DataType
                     Complex64    132 bytes  DataType
            CompositeException    112 bytes  DataType
                     Condition    112 bytes  DataType
                     ConjArray    200 bytes  UnionAll
                    ConjMatrix    120 bytes  UnionAll
                    ConjVector    120 bytes  UnionAll
                    Cptrdiff_t     92 bytes  DataType
                        Cshort     92 bytes  DataType
                       Csize_t     92 bytes  DataType
                      Cssize_t     92 bytes  DataType
                       Cstring     92 bytes  DataType
                        Cuchar     92 bytes  DataType
                         Cuint     92 bytes  DataType
                    Cuintmax_t     92 bytes  DataType
                        Culong     92 bytes  DataType
                    Culonglong     92 bytes  DataType
                       Cushort     92 bytes  DataType
                      Cwchar_t     92 bytes  DataType
                      Cwstring     92 bytes  DataType
                          Date    112 bytes  DataType
                    DateFormat     80 bytes  UnionAll
                      DateTime    112 bytes  DataType
                         Dates  22901 KB     Module
                   DenseMatrix     40 bytes  UnionAll
                 DenseVecOrMat     56 bytes  UnionAll
                   DenseVector     40 bytes  UnionAll
                       DevNull      0 bytes  Base.DevNullStream
                      Diagonal     40 bytes  UnionAll
                          Dict     80 bytes  UnionAll
             DimensionMismatch    112 bytes  DataType
                          Dims     40 bytes  UnionAll
                       Display     92 bytes  DataType
                   Distributed  22937 KB     Module
                          Docs  22836 KB     Module
                    ENDIAN_BOM      4 bytes  UInt32
                           ENV      0 bytes  Base.EnvHash with 105 entries
                      EOFError     92 bytes  DataType
                      EachLine    136 bytes  DataType
                          Enum     40 bytes  UnionAll
                     Enumerate     40 bytes  UnionAll
                ErrorException    112 bytes  DataType
            ExponentialBackOff    160 bytes  DataType
                          FFTW    138 KB     Module
                 Factorization     40 bytes  UnionAll
                   FileMonitor    148 bytes  DataType
                        Future    148 bytes  DataType
                          HTML     40 bytes  UnionAll
                     Hermitian    120 bytes  UnionAll
                             I      8 bytes  UniformScaling{Int64}
                      IOBuffer    216 bytes  DataType
                     IOContext     40 bytes  UnionAll
                      IOStream    148 bytes  DataType
                        IPAddr     92 bytes  DataType
                          IPv4    112 bytes  DataType
                          IPv6    112 bytes  DataType
                IndexCartesian     92 bytes  DataType
                   IndexLinear     92 bytes  DataType
                    IndexStyle     92 bytes  DataType
                           Inf      8 bytes  Float64
                         Inf16      2 bytes  Float16
                         Inf32      4 bytes  Float32
                         Inf64      8 bytes  Float64
                     InitError    124 bytes  DataType
                 InsertionSort      0 bytes  Base.Sort.InsertionSortAlg
                        IntSet    112 bytes  DataType
         InvalidStateException    124 bytes  DataType
                    Irrational     40 bytes  UnionAll
                     Iterators  22671 KB     Module
                    JULIA_HOME     49 bytes  String
                      KeyError    112 bytes  DataType
                        LAPACK  23593 KB     Module
                     LOAD_PATH    156 bytes  2-element Array{Any,1}
                       LibGit2  23036 KB     Module
                          Libc  22629 KB     Module
                         Libdl  22620 KB     Module
                        LinAlg  25047 KB     Module
                      LinSpace     40 bytes  UnionAll
                     LoadError    136 bytes  DataType
               LowerTriangular    120 bytes  UnionAll
                          MIME     40 bytes  UnionAll
                      Markdown  23030 KB     Module
                        Matrix     40 bytes  UnionAll
                     MergeSort      0 bytes  Base.Sort.MergeSortAlg
               MersenneTwister    148 bytes  DataType
                          Meta  22626 KB     Module
                   MethodError    136 bytes  DataType
                          Mmap     47 KB     Module
                        NTuple     80 bytes  UnionAll
                           NaN      8 bytes  Float64
                         NaN16      2 bytes  Float16
                         NaN32      4 bytes  Float32
                         NaN64      8 bytes  Float64
                 NullException     92 bytes  DataType
                      Nullable     40 bytes  UnionAll
                  ObjectIdDict    124 bytes  DataType
                     Operators     16 bytes  Module
                  OrdinalRange     80 bytes  UnionAll
                  PROGRAM_FILE     51 bytes  String
                          Pair     80 bytes  UnionAll
                    ParseError    112 bytes  DataType
              PartialQuickSort    136 bytes  UnionAll
             PermutedDimsArray    280 bytes  UnionAll
                          Pipe    124 bytes  DataType
                    PipeBuffer      0 bytes  Base.#PipeBuffer
                           Pkg  22958 KB     Module
            PollingFileWatcher    160 bytes  DataType
        ProcessExitedException     92 bytes  DataType
                       Profile  22695 KB     Module
                     QuickSort      0 bytes  Base.Sort.QuickSortAlg
                  RandomDevice    124 bytes  DataType
                         Range     40 bytes  UnionAll
                    RangeIndex     16 bytes  Union
                      Rational     40 bytes  UnionAll
                         RawFD    112 bytes  DataType
                 ReentrantLock    136 bytes  DataType
                         Regex    184 bytes  DataType
                    RegexMatch    160 bytes  DataType
                 RemoteChannel     40 bytes  UnionAll
               RemoteException    124 bytes  DataType
                     RevString     40 bytes  UnionAll
                     RoundDown      0 bytes  RoundingMode{:Down}
                 RoundFromZero      0 bytes  RoundingMode{:FromZero}
                  RoundNearest      0 bytes  RoundingMode{:Nearest}
          RoundNearestTiesAway      0 bytes  RoundingMode{:NearestTiesAway}
            RoundNearestTiesUp      0 bytes  RoundingMode{:NearestTiesUp}
                   RoundToZero      0 bytes  RoundingMode{:ToZero}
                       RoundUp      0 bytes  RoundingMode{:Up}
                  RoundingMode     40 bytes  UnionAll
                     RowVector    120 bytes  UnionAll
                        STDERR    359 bytes  IJulia.IJuliaStdio{Base.PipeEndpoi…
                         STDIN    358 bytes  IJulia.IJuliaStdio{Base.PipeEndpoi…
                        STDOUT    359 bytes  IJulia.IJuliaStdio{Base.PipeEndpoi…
            SerializationState     40 bytes  UnionAll
                    Serializer  22711 KB     Module
                           Set     40 bytes  UnionAll
                   SharedArray     80 bytes  UnionAll
                  SharedMatrix     40 bytes  UnionAll
                  SharedVector     40 bytes  UnionAll
                  SparseArrays  23257 KB     Module
               SparseMatrixCSC     80 bytes  UnionAll
                  SparseVector     80 bytes  UnionAll
                    StackFrame    184 bytes  DataType
                    StackTrace    124 bytes  DataType
                   StackTraces  22657 KB     Module
                     StepRange     80 bytes  UnionAll
                  StepRangeLen    120 bytes  UnionAll
                  StridedArray    696 bytes  UnionAll
                 StridedMatrix    656 bytes  UnionAll
               StridedVecOrMat    848 bytes  UnionAll
                 StridedVector    656 bytes  UnionAll
                      SubArray    200 bytes  UnionAll
                     SubString     40 bytes  UnionAll
                SymTridiagonal     40 bytes  UnionAll
                     Symmetric    120 bytes  UnionAll
                           Sys  22658 KB     Module
                   SystemError    136 bytes  DataType
                     TCPSocket    208 bytes  DataType
                          Test  22747 KB     Module
                          Text     40 bytes  UnionAll
                   TextDisplay    112 bytes  DataType
                       Threads  22742 KB     Module
                         Timer    136 bytes  DataType
                   Tridiagonal     40 bytes  UnionAll
                     TypeError    188 bytes  DataType
                     UDPSocket    160 bytes  DataType
                  UnicodeError    136 bytes  DataType
                UniformScaling     40 bytes  UnionAll
                     UnitRange     40 bytes  UnionAll
               UpperTriangular    120 bytes  UnionAll
                       VERSION     40 bytes  VersionNumber
                           Val     40 bytes  UnionAll
                      VecOrMat     56 bytes  UnionAll
                        Vector     40 bytes  UnionAll
                 VersionNumber    160 bytes  DataType
                   WeakKeyDict     80 bytes  UnionAll
                  WorkerConfig    316 bytes  DataType
                    WorkerPool    176 bytes  DataType
                             \      0 bytes  Base.#\
                             ^      0 bytes  Base.#^
                __precompile__      0 bytes  Base.#__precompile__
                           abs      0 bytes  Base.#abs
                          abs2      0 bytes  Base.#abs2
                       abspath      0 bytes  Base.Filesystem.#abspath
                        accept      0 bytes  Base.#accept
                    accumulate      0 bytes  Base.#accumulate
                   accumulate!      0 bytes  Base.#accumulate!
                          acos      0 bytes  Base.#acos
                         acosd      0 bytes  Base.Math.#acosd
                         acosh      0 bytes  Base.#acosh
                          acot      0 bytes  Base.Math.#acot
                         acotd      0 bytes  Base.Math.#acotd
                         acoth      0 bytes  Base.Math.#acoth
                          acsc      0 bytes  Base.Math.#acsc
                         acscd      0 bytes  Base.Math.#acscd
                         acsch      0 bytes  Base.Math.#acsch
                      addprocs      0 bytes  Base.Distributed.#addprocs
                          airy      0 bytes  Base.#airy
                        airyai      0 bytes  Base.#airyai
                   airyaiprime      0 bytes  Base.#airyaiprime
                  airyaiprimex      0 bytes  Base.#airyaiprimex
                       airyaix      0 bytes  Base.#airyaix
                        airybi      0 bytes  Base.#airybi
                   airybiprime      0 bytes  Base.#airybiprime
                  airybiprimex      0 bytes  Base.#airybiprimex
                       airybix      0 bytes  Base.#airybix
                     airyprime      0 bytes  Base.#airyprime
                         airyx      0 bytes  Base.#airyx
                           all      0 bytes  Base.#all
                          all!      0 bytes  Base.#all!
                     allunique      0 bytes  Base.#allunique
                         angle      0 bytes  Base.#angle
                           any      0 bytes  Base.#any
                          any!      0 bytes  Base.#any!
                       append!      0 bytes  Base.#append!
                       apropos      0 bytes  Base.Docs.#apropos
                         ascii      0 bytes  Base.#ascii
                          asec      0 bytes  Base.Math.#asec
                         asecd      0 bytes  Base.Math.#asecd
                         asech      0 bytes  Base.Math.#asech
                          asin      0 bytes  Base.#asin
                         asind      0 bytes  Base.Math.#asind
                         asinh      0 bytes  Base.#asinh
                        assert      0 bytes  Base.#assert
                      asyncmap      0 bytes  Base.#asyncmap
                     asyncmap!      0 bytes  Base.#asyncmap!
                          atan      0 bytes  Base.#atan
                         atan2      0 bytes  Base.Math.#atan2
                         atand      0 bytes  Base.Math.#atand
                         atanh      0 bytes  Base.#atanh
                        atexit      0 bytes  Base.#atexit
                    atreplinit      0 bytes  Base.#atreplinit
                     backtrace      0 bytes  Base.#backtrace
                          base      0 bytes  Base.#base
                  base64decode      0 bytes  Base.Base64.#base64decode
                  base64encode      0 bytes  Base.Base64.#base64encode
                      basename      0 bytes  Base.Filesystem.#basename
                       besselh      0 bytes  Base.#besselh
                      besselhx      0 bytes  Base.#besselhx
                       besseli      0 bytes  Base.#besseli
                      besselix      0 bytes  Base.#besselix
                       besselj      0 bytes  Base.#besselj
                      besselj0      0 bytes  Base.#besselj0
                      besselj1      0 bytes  Base.#besselj1
                      besseljx      0 bytes  Base.#besseljx
                       besselk      0 bytes  Base.#besselk
                      besselkx      0 bytes  Base.#besselkx
                       bessely      0 bytes  Base.#bessely
                      bessely0      0 bytes  Base.#bessely0
                      bessely1      0 bytes  Base.#bessely1
                      besselyx      0 bytes  Base.#besselyx
                          beta      0 bytes  Base.Math.#beta
                          bfft      0 bytes  Base.DFT.#bfft
                         bfft!      0 bytes  Base.DFT.#bfft!
                           big      0 bytes  Base.#big
                           bin      0 bytes  Base.#bin
                          bind      0 bytes  Base.#bind
                      binomial      0 bytes  Base.#binomial
                  bitbroadcast      0 bytes  Base.#bitbroadcast
                       bitrand      0 bytes  Base.Random.#bitrand
                          bits      0 bytes  Base.#bits
                        bkfact      0 bytes  Base.LinAlg.#bkfact
                       bkfact!      0 bytes  Base.LinAlg.#bkfact!
                       blkdiag      0 bytes  Base.SparseArrays.#blkdiag
                         brfft      0 bytes  Base.DFT.#brfft
                     broadcast      0 bytes  Base.#broadcast
                    broadcast!      0 bytes  Base.#broadcast!
            broadcast_getindex      0 bytes  Base.Broadcast.#broadcast_getindex
           broadcast_setindex!      0 bytes  Base.Broadcast.#broadcast_setindex!
                         bswap      0 bytes  Base.#bswap
                     bytes2hex      0 bytes  Base.#bytes2hex
                           cat      0 bytes  Base.#cat
                       catalan      0 bytes  Irrational{:catalan}
               catch_backtrace      0 bytes  Base.#catch_backtrace
              catch_stacktrace      0 bytes  Base.StackTraces.#catch_stacktrace
                          cbrt      0 bytes  Base.Math.#cbrt
                            cd      0 bytes  Base.Filesystem.#cd
                          ceil      0 bytes  Base.#ceil
                     cfunction      0 bytes  Base.#cfunction
                       cglobal      4 bytes  Core.IntrinsicFunction
                     charwidth      0 bytes  Base.UTF8proc.#charwidth
                   checkbounds      0 bytes  Base.#checkbounds
                    checkindex      0 bytes  Base.#checkindex
                         chmod      0 bytes  Base.Filesystem.#chmod
                          chol      0 bytes  Base.LinAlg.#chol
                      cholfact      0 bytes  Base.LinAlg.#cholfact
                     cholfact!      0 bytes  Base.LinAlg.#cholfact!
                         chomp      0 bytes  Base.#chomp
                          chop      0 bytes  Base.#chop
                         chown      0 bytes  Base.Filesystem.#chown
                       chr2ind      0 bytes  Base.#chr2ind
                     circcopy!      0 bytes  Base.#circcopy!
                     circshift      0 bytes  Base.#circshift
                    circshift!      0 bytes  Base.#circshift!
                           cis      0 bytes  Base.#cis
                         clamp      0 bytes  Base.Math.#clamp
                        clamp!      0 bytes  Base.Math.#clamp!
                           cld      0 bytes  Base.#cld
                        clear!      0 bytes  Base.Distributed.#clear!
                     clipboard      0 bytes  Base.#clipboard
                         close      0 bytes  Base.#close
                           cmp      0 bytes  Base.#cmp
                     code_llvm      0 bytes  Base.#code_llvm
                  code_lowered      0 bytes  Base.#code_lowered
                   code_native      0 bytes  Base.#code_native
                    code_typed      0 bytes  Base.#code_typed
                 code_warntype      0 bytes  Base.#code_warntype
                      codeunit      0 bytes  Base.#codeunit
                       collect      0 bytes  Base.#collect
                         colon      0 bytes  Base.#colon
                       complex      0 bytes  Base.#complex
                          cond      0 bytes  Base.LinAlg.#cond
                     condskeel      0 bytes  Base.LinAlg.#condskeel
                          conj      0 bytes  Base.#conj
                         conj!      0 bytes  Base.#conj!
                       connect      0 bytes  Base.#connect
                       consume      0 bytes  Base.#consume
                      contains      0 bytes  Base.#contains
                          conv      0 bytes  Base.DSP.#conv
                         conv2      0 bytes  Base.DSP.#conv2
                       convert      0 bytes  Base.#convert
                          copy      0 bytes  Base.#copy
                         copy!      0 bytes  Base.#copy!
                      copysign      0 bytes  Base.#copysign
                           cor      0 bytes  Base.#cor
                           cos      0 bytes  Base.#cos
                          cosc      0 bytes  Base.Math.#cosc
                          cosd      0 bytes  Base.Math.#cosd
                          cosh      0 bytes  Base.#cosh
                         cospi      0 bytes  Base.Math.#cospi
                           cot      0 bytes  Base.Math.#cot
                          cotd      0 bytes  Base.Math.#cotd
                          coth      0 bytes  Base.Math.#coth
                         count      0 bytes  Base.#count
                    count_ones      0 bytes  Base.#count_ones
                   count_zeros      0 bytes  Base.#count_zeros
                    countlines      0 bytes  Base.DataFmt.#countlines
                       countnz      0 bytes  Base.#countnz
                           cov      0 bytes  Base.#cov
                            cp      0 bytes  Base.Filesystem.#cp
                         cross      0 bytes  Base.LinAlg.#cross
                           csc      0 bytes  Base.Math.#csc
                          cscd      0 bytes  Base.Math.#cscd
                          csch      0 bytes  Base.Math.#csch
                         ctime      0 bytes  Base.Filesystem.#ctime
                    ctranspose      0 bytes  Base.#ctranspose
                   ctranspose!      0 bytes  Base.LinAlg.#ctranspose!
                        cummax      0 bytes  Base.#cummax
                        cummin      0 bytes  Base.#cummin
                       cumprod      0 bytes  Base.#cumprod
                      cumprod!      0 bytes  Base.#cumprod!
                        cumsum      0 bytes  Base.#cumsum
                       cumsum!      0 bytes  Base.#cumsum!
                    cumsum_kbn      0 bytes  Base.#cumsum_kbn
                current_module      0 bytes  Base.#current_module
                  current_task      0 bytes  Base.#current_task
                        dawson      0 bytes  Base.#dawson
                           dct      0 bytes  Base.DFT.FFTW.#dct
                          dct!      0 bytes  Base.DFT.FFTW.#dct!
                           dec      0 bytes  Base.#dec
                        deconv      0 bytes  Base.DSP.#deconv
                      deepcopy      0 bytes  Base.#deepcopy
           default_worker_pool      0 bytes  Base.Distributed.#default_worker_p…
                       deg2rad      0 bytes  Base.Math.#deg2rad
                       delete!      0 bytes  Base.#delete!
                     deleteat!      0 bytes  Base.#deleteat!
                           den      0 bytes  Base.#den
                   denominator      0 bytes  Base.#denominator
                   deserialize      0 bytes  Base.Serializer.#deserialize
                           det      0 bytes  Base.LinAlg.#det
                        detach      0 bytes  Base.#detach
                          diag      0 bytes  Base.LinAlg.#diag
                       diagind      0 bytes  Base.LinAlg.#diagind
                         diagm      0 bytes  Base.LinAlg.#diagm
                          diff      0 bytes  Base.LinAlg.#diff
                       digamma      0 bytes  Base.#digamma
                        digits      0 bytes  Base.#digits
                       digits!      0 bytes  Base.#digits!
                       dirname      0 bytes  Base.Filesystem.#dirname
                disable_sigint      0 bytes  Base.#disable_sigint
                       display      0 bytes  Base.Multimedia.#display
                   displayable      0 bytes  Base.Multimedia.#displayable
                   displaysize      0 bytes  Base.#displaysize
                           div      0 bytes  Base.#div
                        divrem      0 bytes  Base.#divrem
                          done      0 bytes  Base.#done
                           dot      0 bytes  Base.LinAlg.#dot
                      download      0 bytes  Base.#download
                     dropzeros      0 bytes  Base.SparseArrays.#dropzeros
                    dropzeros!      0 bytes  Base.SparseArrays.#dropzeros!
                          dump      0 bytes  Base.#dump
                             e      0 bytes  Irrational{:e}
                     eachindex      0 bytes  Base.#eachindex
                      eachline      0 bytes  Base.#eachline
                     eachmatch      0 bytes  Base.#eachmatch
                          edit      0 bytes  Base.#edit
                           eig      0 bytes  Base.LinAlg.#eig
                       eigfact      0 bytes  Base.LinAlg.#eigfact
                      eigfact!      0 bytes  Base.LinAlg.#eigfact!
                        eigmax      0 bytes  Base.LinAlg.#eigmax
                        eigmin      0 bytes  Base.LinAlg.#eigmin
                          eigs      0 bytes  Base.LinAlg.#eigs
                       eigvals      0 bytes  Base.LinAlg.#eigvals
                      eigvals!      0 bytes  Base.LinAlg.#eigvals!
                       eigvecs      0 bytes  Base.LinAlg.#eigvecs
                        eltype      0 bytes  Base.#eltype
                        empty!      0 bytes  Base.#empty!
                         endof      0 bytes  Base.#endof
                      endswith      0 bytes  Base.#endswith
                     enumerate      0 bytes  Base.Iterators.#enumerate
                           eof      0 bytes  Base.#eof
                           eps      0 bytes  Base.#eps
                           erf      0 bytes  Base.#erf
                          erfc      0 bytes  Base.#erfc
                       erfcinv      0 bytes  Base.#erfcinv
                         erfcx      0 bytes  Base.#erfcx
                          erfi      0 bytes  Base.#erfi
                        erfinv      0 bytes  Base.#erfinv
                         error      0 bytes  Base.#error
                           esc      0 bytes  Base.#esc
                 escape_string      0 bytes  Base.#escape_string
                           eta      0 bytes  Base.#eta
                            eu      0 bytes  Irrational{:e}
                    eulergamma      0 bytes  Irrational{:γ}
                      evalfile      0 bytes  Base.#evalfile
                          exit      0 bytes  Base.#exit
                           exp      0 bytes  Base.#exp
                         exp10      0 bytes  Base.#exp10
                          exp2      0 bytes  Base.#exp2
                        expand      0 bytes  Base.#expand
                    expanduser      0 bytes  Base.Filesystem.#expanduser
                          expm      0 bytes  Base.LinAlg.#expm
                         expm1      0 bytes  Base.#expm1
                      exponent      0 bytes  Base.Math.#exponent
                       extrema      0 bytes  Base.#extrema
                           eye      0 bytes  Base.#eye
                     factorial      0 bytes  Base.#factorial
                     factorize      0 bytes  Base.LinAlg.#factorize
                        falses      0 bytes  Base.#falses
                            fd      0 bytes  Base.#fd
                          fdio      0 bytes  Base.#fdio
                         fetch      0 bytes  Base.#fetch
                           fft      0 bytes  Base.DFT.#fft
                          fft!      0 bytes  Base.DFT.#fft!
                      fftshift      0 bytes  Base.DFT.#fftshift
                     fieldname      0 bytes  Base.#fieldname
                    fieldnames      0 bytes  Base.#fieldnames
                   fieldoffset      0 bytes  Base.#fieldoffset
                      filemode      0 bytes  Base.Filesystem.#filemode
                      filesize      0 bytes  Base.Filesystem.#filesize
                          fill      0 bytes  Base.#fill
                         fill!      0 bytes  Base.#fill!
                          filt      0 bytes  Base.DSP.#filt
                         filt!      0 bytes  Base.DSP.#filt!
                        filter      0 bytes  Base.#filter
                       filter!      0 bytes  Base.#filter!
                      finalize      0 bytes  Base.#finalize
                     finalizer      0 bytes  Base.#finalizer
                          find      0 bytes  Base.#find
                     findfirst      0 bytes  Base.#findfirst
                        findin      0 bytes  Base.#findin
                      findlast      0 bytes  Base.#findlast
                       findmax      0 bytes  Base.#findmax
                      findmax!      0 bytes  Base.#findmax!
                       findmin      0 bytes  Base.#findmin
                      findmin!      0 bytes  Base.#findmin!
                         findn      0 bytes  Base.#findn
                      findnext      0 bytes  Base.#findnext
                        findnz      0 bytes  Base.#findnz
                      findprev      0 bytes  Base.#findprev
                         first      0 bytes  Base.#first
                           fld      0 bytes  Base.#fld
                          fld1      0 bytes  Base.#fld1
                        fldmod      0 bytes  Base.#fldmod
                       fldmod1      0 bytes  Base.#fldmod1
                     flipbits!      0 bytes  Base.#flipbits!
                       flipdim      0 bytes  Base.#flipdim
                      flipsign      0 bytes  Base.#flipsign
                         float      0 bytes  Base.#float
                         floor      0 bytes  Base.#floor
                         flush      0 bytes  Base.#flush
                           fma      0 bytes  Base.#fma
                         foldl      0 bytes  Base.#foldl
                         foldr      0 bytes  Base.#foldr
                       foreach      0 bytes  Base.#foreach
                         frexp      0 bytes  Base.Math.#frexp
                          full      0 bytes  Base.#full
                      fullname      0 bytes  Base.#fullname
                   functionloc      0 bytes  Base.#functionloc
                         gamma      0 bytes  Base.Math.#gamma
                            gc      0 bytes  Base.#gc
                     gc_enable      0 bytes  Base.#gc_enable
                           gcd      0 bytes  Base.#gcd
                          gcdx      0 bytes  Base.#gcdx
                        gensym      0 bytes  Base.#gensym
                           get      0 bytes  Base.#get
                          get!      0 bytes  Base.#get!
           get_zero_subnormals      0 bytes  Base.Rounding.#get_zero_subnormals
                   getaddrinfo      0 bytes  Base.#getaddrinfo
                   gethostname      0 bytes  Base.Libc.#gethostname
                      getindex      0 bytes  Base.#getindex
                     getipaddr      0 bytes  Base.#getipaddr
                        getkey      0 bytes  Base.#getkey
                        getpid      0 bytes  Base.Libc.#getpid
                   getsockname      0 bytes  Base.#getsockname
                        givens      0 bytes  Base.LinAlg.#givens
                        golden      0 bytes  Irrational{:φ}
                         gperm      0 bytes  Base.Filesystem.#gperm
                      gradient      0 bytes  Base.LinAlg.#gradient
                     graphemes      0 bytes  Base.UTF8proc.#graphemes
                      hankelh1      0 bytes  Base.#hankelh1
                     hankelh1x      0 bytes  Base.#hankelh1x
                      hankelh2      0 bytes  Base.#hankelh2
                     hankelh2x      0 bytes  Base.#hankelh2x
                          hash      0 bytes  Base.#hash
                        haskey      0 bytes  Base.#haskey
                          hcat      0 bytes  Base.#hcat
                      hessfact      0 bytes  Base.LinAlg.#hessfact
                     hessfact!      0 bytes  Base.LinAlg.#hessfact!
                           hex      0 bytes  Base.#hex
                     hex2bytes      0 bytes  Base.#hex2bytes
                       hex2num      0 bytes  Base.#hex2num
                       homedir      0 bytes  Base.Filesystem.#homedir
                          htol      0 bytes  Base.#htol
                          hton      0 bytes  Base.#hton
                         hvcat      0 bytes  Base.#hvcat
                         hypot      0 bytes  Base.Math.#hypot
                          idct      0 bytes  Base.DFT.FFTW.#idct
                         idct!      0 bytes  Base.DFT.FFTW.#idct!
                      identity      0 bytes  Base.#identity
                        ifelse      0 bytes  Base.#ifelse
                          ifft      0 bytes  Base.DFT.#ifft
                         ifft!      0 bytes  Base.DFT.#ifft!
                     ifftshift      0 bytes  Base.DFT.#ifftshift
                  ignorestatus      0 bytes  Base.#ignorestatus
                            im      2 bytes  Complex{Bool}
                          imag      0 bytes  Base.#imag
                            in      0 bytes  Base.#in
                       include      0 bytes  Base.#include
            include_dependency      0 bytes  Base.#include_dependency
                include_string      0 bytes  Base.#include_string
                       ind2chr      0 bytes  Base.#ind2chr
                       ind2sub      0 bytes  Base.#ind2sub
                       indexin      0 bytes  Base.#indexin
                     indexpids      0 bytes  Base.#indexpids
                       indices      0 bytes  Base.#indices
                        indmax      0 bytes  Base.#indmax
                        indmin      0 bytes  Base.#indmin
                          info      0 bytes  Base.#info
                   init_worker      0 bytes  Base.Distributed.#init_worker
                       insert!      0 bytes  Base.#insert!
                     instances      0 bytes  Base.#instances
                     interrupt      0 bytes  Base.Distributed.#interrupt
                     intersect      0 bytes  Base.#intersect
                    intersect!      0 bytes  Base.#intersect!
                           inv      0 bytes  Base.#inv
                    invdigamma      0 bytes  Base.#invdigamma
                        invmod      0 bytes  Base.#invmod
                       invperm      0 bytes  Base.#invperm
                     ipermute!      0 bytes  Base.#ipermute!
                  ipermutedims      0 bytes  Base.#ipermutedims
                         irfft      0 bytes  Base.DFT.#irfft
                            is      0 bytes  Base.#is
                      is_apple      0 bytes  Base.#is_apple
              is_assigned_char      0 bytes  Base.UTF8proc.#is_assigned_char
                        is_bsd      0 bytes  Base.#is_bsd
                      is_linux      0 bytes  Base.#is_linux
                       is_unix      0 bytes  Base.#is_unix
                    is_windows      0 bytes  Base.#is_windows
                     isabspath      0 bytes  Base.Filesystem.#isabspath
                       isalnum      0 bytes  Base.UTF8proc.#isalnum
                       isalpha      0 bytes  Base.UTF8proc.#isalpha
                      isapprox      0 bytes  Base.#isapprox
                       isascii      0 bytes  Base.#isascii
                    isassigned      0 bytes  Base.#isassigned
                        isbits      0 bytes  Base.#isbits
                    isblockdev      0 bytes  Base.Filesystem.#isblockdev
                     ischardev      0 bytes  Base.Filesystem.#ischardev
                       iscntrl      0 bytes  Base.UTF8proc.#iscntrl
                       isconst      0 bytes  Base.#isconst
                        isdiag      0 bytes  Base.LinAlg.#isdiag
                       isdigit      0 bytes  Base.UTF8proc.#isdigit
                         isdir      0 bytes  Base.Filesystem.#isdir
                     isdirpath      0 bytes  Base.Filesystem.#isdirpath
                       isempty      0 bytes  Base.#isempty
                       isequal      0 bytes  Base.#isequal
                        iseven      0 bytes  Base.#iseven
                        isfifo      0 bytes  Base.Filesystem.#isfifo
                        isfile      0 bytes  Base.Filesystem.#isfile
                      isfinite      0 bytes  Base.#isfinite
                       isgraph      0 bytes  Base.UTF8proc.#isgraph
                   ishermitian      0 bytes  Base.LinAlg.#ishermitian
                        isimag      0 bytes  Base.#isimag
                   isimmutable      0 bytes  Base.#isimmutable
                         isinf      0 bytes  Base.#isinf
                     isinteger      0 bytes  Base.#isinteger
                 isinteractive      0 bytes  Base.#isinteractive
                    isleaftype      0 bytes  Base.#isleaftype
                        isless      0 bytes  Base.#isless
                        islink      0 bytes  Base.Filesystem.#islink
                      islocked      0 bytes  Base.#islocked
                       islower      0 bytes  Base.UTF8proc.#islower
                      ismarked      0 bytes  Base.#ismarked
                       ismatch      0 bytes  Base.#ismatch
                       ismount      0 bytes  Base.Filesystem.#ismount
                         isnan      0 bytes  Base.#isnan
                        isnull      0 bytes  Base.#isnull
                      isnumber      0 bytes  Base.UTF8proc.#isnumber
                         isodd      0 bytes  Base.#isodd
                        isopen      0 bytes  Base.#isopen
                        ispath      0 bytes  Base.Filesystem.#ispath
                        isperm      0 bytes  Base.#isperm
                      isposdef      0 bytes  Base.LinAlg.#isposdef
                     isposdef!      0 bytes  Base.LinAlg.#isposdef!
                        ispow2      0 bytes  Base.#ispow2
                       isprint      0 bytes  Base.UTF8proc.#isprint
                       ispunct      0 bytes  Base.UTF8proc.#ispunct
                         isqrt      0 bytes  Base.#isqrt
                    isreadable      0 bytes  Base.#isreadable
                    isreadonly      0 bytes  Base.#isreadonly
                       isready      0 bytes  Base.#isready
                        isreal      0 bytes  Base.#isreal
                      issetgid      0 bytes  Base.Filesystem.#issetgid
                      issetuid      0 bytes  Base.Filesystem.#issetuid
                      issocket      0 bytes  Base.Filesystem.#issocket
                      issorted      0 bytes  Base.#issorted
                       isspace      0 bytes  Base.UTF8proc.#isspace
                      issparse      0 bytes  Base.SparseArrays.#issparse
                      issticky      0 bytes  Base.Filesystem.#issticky
                   issubnormal      0 bytes  Base.#issubnormal
                      issubset      0 bytes  Base.#issubset
                   issymmetric      0 bytes  Base.LinAlg.#issymmetric
                    istaskdone      0 bytes  Base.#istaskdone
                 istaskstarted      0 bytes  Base.#istaskstarted
                    istextmime      0 bytes  Base.Multimedia.#istextmime
                        istril      0 bytes  Base.LinAlg.#istril
                        istriu      0 bytes  Base.LinAlg.#istriu
                       isupper      0 bytes  Base.UTF8proc.#isupper
                       isvalid      0 bytes  Base.#isvalid
                    iswritable      0 bytes  Base.#iswritable
                      isxdigit      0 bytes  Base.#isxdigit
                        iszero      0 bytes  Base.#iszero
                          join      0 bytes  Base.#join
                      joinpath      0 bytes  Base.Filesystem.#joinpath
                          keys      0 bytes  Base.#keys
                       keytype      0 bytes  Base.#keytype
                          kill      0 bytes  Base.#kill
                          kron      0 bytes  Base.#kron
                          last      0 bytes  Base.#last
                        launch      0 bytes  Base.Distributed.#launch
                         lbeta      0 bytes  Base.Math.#lbeta
                       lcfirst      0 bytes  Base.#lcfirst
                           lcm      0 bytes  Base.#lcm
                         ldexp      0 bytes  Base.Math.#ldexp
                      ldltfact      0 bytes  Base.LinAlg.#ldltfact
                     ldltfact!      0 bytes  Base.LinAlg.#ldltfact!
                  leading_ones      0 bytes  Base.#leading_ones
                 leading_zeros      0 bytes  Base.#leading_zeros
                        length      0 bytes  Base.#length
                          less      0 bytes  Base.#less
                        lexcmp      0 bytes  Base.#lexcmp
                       lexless      0 bytes  Base.#lexless
                         lfact      0 bytes  Base.Math.#lfact
                        lgamma      0 bytes  Base.Math.#lgamma
                 linearindices      0 bytes  Base.#linearindices
                        linreg      0 bytes  Base.LinAlg.#linreg
                      linspace      0 bytes  Base.#linspace
                        listen      0 bytes  Base.#listen
                     listenany      0 bytes  Base.#listenany
                  localindexes      0 bytes  Base.#localindexes
                          lock      0 bytes  Base.#lock
                           log      0 bytes  Base.#log
                         log10      0 bytes  Base.#log10
                         log1p      0 bytes  Base.#log1p
                          log2      0 bytes  Base.#log2
                     logabsdet      0 bytes  Base.LinAlg.#logabsdet
                        logdet      0 bytes  Base.LinAlg.#logdet
                       logging      0 bytes  Base.#logging
                          logm      0 bytes  Base.LinAlg.#logm
                      logspace      0 bytes  Base.#logspace
                     lowercase      0 bytes  Base.#lowercase
                          lpad      0 bytes  Base.#lpad
                            lq      0 bytes  Base.LinAlg.#lq
                        lqfact      0 bytes  Base.LinAlg.#lqfact
                       lqfact!      0 bytes  Base.LinAlg.#lqfact!
                         lstat      0 bytes  Base.Filesystem.#lstat
                        lstrip      0 bytes  Base.#lstrip
                          ltoh      0 bytes  Base.#ltoh
                            lu      0 bytes  Base.LinAlg.#lu
                        lufact      0 bytes  Base.LinAlg.#lufact
                       lufact!      0 bytes  Base.LinAlg.#lufact!
                          lyap      0 bytes  Base.LinAlg.#lyap
                   macroexpand      0 bytes  Base.#macroexpand
                        manage      0 bytes  Base.Distributed.#manage
                           map      0 bytes  Base.#map
                          map!      0 bytes  Base.#map!
                      mapfoldl      0 bytes  Base.#mapfoldl
                      mapfoldr      0 bytes  Base.#mapfoldr
                     mapreduce      0 bytes  Base.#mapreduce
                  mapreducedim      0 bytes  Base.#mapreducedim
                     mapslices      0 bytes  Base.#mapslices
                          mark      0 bytes  Base.#mark
                         match      0 bytes  Base.#match
                      matchall      0 bytes  Base.#matchall
                           max      0 bytes  Base.#max
                        maxabs      0 bytes  Base.#maxabs
                       maximum      0 bytes  Base.#maximum
                      maximum!      0 bytes  Base.#maximum!
                   maxintfloat      0 bytes  Base.#maxintfloat
                          mean      0 bytes  Base.#mean
                         mean!      0 bytes  Base.#mean!
                        median      0 bytes  Base.#median
                       median!      0 bytes  Base.#median!
                         merge      0 bytes  Base.#merge
                        merge!      0 bytes  Base.#merge!
                 method_exists      0 bytes  Base.#method_exists
                       methods      0 bytes  Base.#methods
                   methodswith      0 bytes  Base.#methodswith
                        middle      0 bytes  Base.#middle
                     midpoints      0 bytes  Base.#midpoints
                  mimewritable      0 bytes  Base.Multimedia.#mimewritable
                           min      0 bytes  Base.#min
                        minabs      0 bytes  Base.#minabs
                       minimum      0 bytes  Base.#minimum
                      minimum!      0 bytes  Base.#minimum!
                        minmax      0 bytes  Base.#minmax
                         mkdir      0 bytes  Base.Filesystem.#mkdir
                        mkpath      0 bytes  Base.Filesystem.#mkpath
                        mktemp      0 bytes  Base.Filesystem.#mktemp
                     mktempdir      0 bytes  Base.Filesystem.#mktempdir
                           mod      0 bytes  Base.#mod
                          mod1      0 bytes  Base.#mod1
                        mod2pi      0 bytes  Base.Math.#mod2pi
                          modf      0 bytes  Base.Math.#modf
                   module_name      0 bytes  Base.#module_name
                 module_parent      0 bytes  Base.#module_parent
                         mtime      0 bytes  Base.Filesystem.#mtime
                        muladd      0 bytes  Base.#muladd
                            mv      0 bytes  Base.Filesystem.#mv
                          myid      0 bytes  Base.Distributed.#myid
                         names      0 bytes  Base.#names
                  nb_available      0 bytes  Base.#nb_available
                       ndigits      0 bytes  Base.#ndigits
                         ndims      0 bytes  Base.#ndims
                          next      0 bytes  Base.#next
                     nextfloat      0 bytes  Base.#nextfloat
                       nextind      0 bytes  Base.#nextind
                       nextpow      0 bytes  Base.#nextpow
                      nextpow2      0 bytes  Base.#nextpow2
                      nextprod      0 bytes  Base.#nextprod
                           nnz      0 bytes  Base.SparseArrays.#nnz
                      nonzeros      0 bytes  Base.SparseArrays.#nonzeros
                          norm      0 bytes  Base.LinAlg.#norm
                     normalize      0 bytes  Base.LinAlg.#normalize
                    normalize!      0 bytes  Base.LinAlg.#normalize!
              normalize_string      0 bytes  Base.UTF8proc.#normalize_string
                      normpath      0 bytes  Base.Filesystem.#normpath
                        notify      0 bytes  Base.#notify
                           now      0 bytes  Base.Dates.#now
                        nprocs      0 bytes  Base.Distributed.#nprocs
                          ntoh      0 bytes  Base.#ntoh
                        ntuple      0 bytes  Base.#ntuple
                     nullspace      0 bytes  Base.LinAlg.#nullspace
                           num      0 bytes  Base.#num
                       num2hex      0 bytes  Base.#num2hex
                     numerator      0 bytes  Base.#numerator
                      nworkers      0 bytes  Base.Distributed.#nworkers
                       nzrange      0 bytes  Base.SparseArrays.#nzrange
                     object_id      0 bytes  Base.#object_id
                           oct      0 bytes  Base.#oct
                        oftype      0 bytes  Base.#oftype
                           one      0 bytes  Base.#one
                          ones      0 bytes  Base.#ones
                       oneunit      0 bytes  Base.#oneunit
                          open      0 bytes  Base.#open
                         operm      0 bytes  Base.Filesystem.#operm
                      ordschur      0 bytes  Base.LinAlg.#ordschur
                     ordschur!      0 bytes  Base.LinAlg.#ordschur!
                        parent      0 bytes  Base.#parent
                 parentindexes      0 bytes  Base.#parentindexes
                         parse      0 bytes  Base.#parse
                     peakflops      0 bytes  Base.LinAlg.#peakflops
                       permute      0 bytes  Base.SparseArrays.#permute
                      permute!      0 bytes  Base.#permute!
                   permutedims      0 bytes  Base.#permutedims
                  permutedims!      0 bytes  Base.#permutedims!
                            pi      0 bytes  Irrational{:π}
                          pinv      0 bytes  Base.LinAlg.#pinv
                      pipeline      0 bytes  Base.#pipeline
                     plan_bfft      0 bytes  Base.DFT.#plan_bfft
                    plan_bfft!      0 bytes  Base.DFT.#plan_bfft!
                    plan_brfft      0 bytes  Base.DFT.#plan_brfft
                      plan_dct      0 bytes  Base.DFT.FFTW.#plan_dct
                     plan_dct!      0 bytes  Base.DFT.FFTW.#plan_dct!
                      plan_fft      0 bytes  Base.DFT.#plan_fft
                     plan_fft!      0 bytes  Base.DFT.#plan_fft!
                     plan_idct      0 bytes  Base.DFT.FFTW.#plan_idct
                    plan_idct!      0 bytes  Base.DFT.FFTW.#plan_idct!
                     plan_ifft      0 bytes  Base.DFT.#plan_ifft
                    plan_ifft!      0 bytes  Base.DFT.#plan_ifft!
                    plan_irfft      0 bytes  Base.DFT.#plan_irfft
                     plan_rfft      0 bytes  Base.DFT.#plan_rfft
                          pmap      0 bytes  Base.Distributed.#pmap
                       pointer      0 bytes  Base.#pointer
           pointer_from_objref      0 bytes  Base.#pointer_from_objref
                       poll_fd      0 bytes  Base.Filesystem.#poll_fd
                     poll_file      0 bytes  Base.Filesystem.#poll_file
                     polygamma      0 bytes  Base.#polygamma
                          pop!      0 bytes  Base.#pop!
                    popdisplay      0 bytes  Base.Multimedia.#popdisplay
                      position      0 bytes  Base.#position
                      powermod      0 bytes  Base.#powermod
                     precision      0 bytes  Base.#precision
                    precompile      0 bytes  Base.#precompile
                      prepend!      0 bytes  Base.#prepend!
                     prevfloat      0 bytes  Base.#prevfloat
                       prevind      0 bytes  Base.#prevind
                       prevpow      0 bytes  Base.#prevpow
                      prevpow2      0 bytes  Base.#prevpow2
                         print      0 bytes  Base.#print
                print_shortest      0 bytes  Base.Grisu.#print_shortest
              print_with_color      0 bytes  Base.#print_with_color
                       println      0 bytes  Base.#println
                process_exited      0 bytes  Base.#process_exited
               process_running      0 bytes  Base.#process_running
                         procs      0 bytes  Base.Distributed.#procs
                          prod      0 bytes  Base.#prod
                         prod!      0 bytes  Base.#prod!
                       produce      0 bytes  Base.#produce
                       promote      0 bytes  Base.#promote
                  promote_rule      0 bytes  Base.#promote_rule
                 promote_shape      0 bytes  Base.#promote_shape
                  promote_type      0 bytes  Base.#promote_type
                         push!      0 bytes  Base.#push!
                   pushdisplay      0 bytes  Base.Multimedia.#pushdisplay
                          put!      0 bytes  Base.#put!
                           pwd      0 bytes  Base.Filesystem.#pwd
                            qr      0 bytes  Base.LinAlg.#qr
                        qrfact      0 bytes  Base.LinAlg.#qrfact
                       qrfact!      0 bytes  Base.LinAlg.#qrfact!
                        quadgk      0 bytes  Base.#quadgk
                      quantile      0 bytes  Base.#quantile
                     quantile!      0 bytes  Base.#quantile!
                          quit      0 bytes  Base.#quit
                       rad2deg      0 bytes  Base.Math.#rad2deg
                          rand      0 bytes  Base.Random.#rand
                         rand!      0 bytes  Base.Random.#rand!
                     randcycle      0 bytes  Base.Random.#randcycle
                       randexp      0 bytes  Base.Random.#randexp
                      randexp!      0 bytes  Base.Random.#randexp!
                      randjump      0 bytes  Base.Random.#randjump
                         randn      0 bytes  Base.Random.#randn
                        randn!      0 bytes  Base.Random.#randn!
                      randperm      0 bytes  Base.Random.#randperm
                    randstring      0 bytes  Base.Random.#randstring
                    randsubseq      0 bytes  Base.Random.#randsubseq
                   randsubseq!      0 bytes  Base.Random.#randsubseq!
                         range      0 bytes  Base.#range
                          rank      0 bytes  Base.LinAlg.#rank
                   rationalize      0 bytes  Base.#rationalize
                          read      0 bytes  Base.#read
                         read!      0 bytes  Base.#read!
                  readandwrite      0 bytes  Base.#readandwrite
                 readavailable      0 bytes  Base.#readavailable
                    readbytes!      0 bytes  Base.#readbytes!
                     readchomp      0 bytes  Base.#readchomp
                       readcsv      0 bytes  Base.DataFmt.#readcsv
                       readdir      0 bytes  Base.Filesystem.#readdir
                       readdlm      0 bytes  Base.DataFmt.#readdlm
                      readline      0 bytes  Base.#readline
                     readlines      0 bytes  Base.#readlines
                      readlink      0 bytes  Base.Filesystem.#readlink
                    readstring      0 bytes  Base.#readstring
                     readuntil      0 bytes  Base.#readuntil
                          real      0 bytes  Base.#real
                       realmax      0 bytes  Base.#realmax
                       realmin      0 bytes  Base.#realmin
                      realpath      0 bytes  Base.Filesystem.#realpath
                          recv      0 bytes  Base.#recv
                      recvfrom      0 bytes  Base.#recvfrom
               redirect_stderr      0 bytes  Base.#redirect_stderr
                redirect_stdin      0 bytes  Base.#redirect_stdin
               redirect_stdout      0 bytes  Base.#redirect_stdout
                     redisplay      0 bytes  Base.Multimedia.#redisplay
                        reduce      0 bytes  Base.#reduce
                     reducedim      0 bytes  Base.#reducedim
               reenable_sigint      0 bytes  Base.#reenable_sigint
                          reim      0 bytes  Base.#reim
                   reinterpret      0 bytes  Base.#reinterpret
                        reload      0 bytes  Base.#reload
                       relpath      0 bytes  Base.Filesystem.#relpath
                           rem      0 bytes  Base.#rem
                        rem2pi      0 bytes  Base.Math.#rem2pi
                        remote      0 bytes  Base.Distributed.#remote
                     remote_do      0 bytes  Base.Distributed.#remote_do
                    remotecall      0 bytes  Base.Distributed.#remotecall
              remotecall_fetch      0 bytes  Base.Distributed.#remotecall_fetch
               remotecall_wait      0 bytes  Base.Distributed.#remotecall_wait
                        repeat      0 bytes  Base.#repeat
                       replace      0 bytes  Base.#replace
                        repmat      0 bytes  Base.#repmat
                          repr      0 bytes  Base.#repr
                      reprmime      0 bytes  Base.Multimedia.#reprmime
                         reset      0 bytes  Base.#reset
                       reshape      0 bytes  Base.#reshape
                       resize!      0 bytes  Base.#resize!
                       rethrow      0 bytes  Base.#rethrow
                         retry      0 bytes  Base.#retry
                       reverse      0 bytes  Base.#reverse
                      reverse!      0 bytes  Base.#reverse!
                    reverseind      0 bytes  Base.#reverseind
                          rfft      0 bytes  Base.DFT.#rfft
                            rm      0 bytes  Base.Filesystem.#rm
                       rmprocs      0 bytes  Base.Distributed.#rmprocs
                           rol      0 bytes  Base.#rol
                          rol!      0 bytes  Base.#rol!
                           ror      0 bytes  Base.#ror
                          ror!      0 bytes  Base.#ror!
                        rot180      0 bytes  Base.#rot180
                        rotl90      0 bytes  Base.#rotl90
                        rotr90      0 bytes  Base.#rotr90
                         round      0 bytes  Base.#round
                      rounding      0 bytes  Base.Rounding.#rounding
                       rowvals      0 bytes  Base.SparseArrays.#rowvals
                          rpad      0 bytes  Base.#rpad
                       rsearch      0 bytes  Base.#rsearch
                  rsearchindex      0 bytes  Base.#rsearchindex
                        rsplit      0 bytes  Base.#rsplit
                        rstrip      0 bytes  Base.#rstrip
                           run      0 bytes  Base.#run
                        scale!      0 bytes  Base.LinAlg.#scale!
                      schedule      0 bytes  Base.#schedule
                         schur      0 bytes  Base.LinAlg.#schur
                     schurfact      0 bytes  Base.LinAlg.#schurfact
                    schurfact!      0 bytes  Base.LinAlg.#schurfact!
                         sdata      0 bytes  Base.#sdata
                        search      0 bytes  Base.#search
                   searchindex      0 bytes  Base.#searchindex
                  searchsorted      0 bytes  Base.Sort.#searchsorted
             searchsortedfirst      0 bytes  Base.Sort.#searchsortedfirst
              searchsortedlast      0 bytes  Base.Sort.#searchsortedlast
                           sec      0 bytes  Base.Math.#sec
                          secd      0 bytes  Base.Math.#secd
                          sech      0 bytes  Base.Math.#sech
                          seek      0 bytes  Base.#seek
                       seekend      0 bytes  Base.#seekend
                     seekstart      0 bytes  Base.#seekstart
                        select      0 bytes  Base.Sort.#select
                       select!      0 bytes  Base.Sort.#select!
                    selectperm      0 bytes  Base.Sort.#selectperm
                   selectperm!      0 bytes  Base.Sort.#selectperm!
                          send      0 bytes  Base.#send
                     serialize      0 bytes  Base.Serializer.#serialize
           set_zero_subnormals      0 bytes  Base.Rounding.#set_zero_subnormals
                       setdiff      0 bytes  Base.#setdiff
                      setdiff!      0 bytes  Base.#setdiff!
                        setenv      0 bytes  Base.#setenv
                     setindex!      0 bytes  Base.#setindex!
                  setprecision      0 bytes  Base.MPFR.#setprecision
                   setrounding      0 bytes  Base.Rounding.#setrounding
                        shift!      0 bytes  Base.#shift!
                          show      0 bytes  Base.#show
                       showall      0 bytes  Base.#showall
                   showcompact      0 bytes  Base.#showcompact
                     showerror      0 bytes  Base.#showerror
                       shuffle      0 bytes  Base.Random.#shuffle
                      shuffle!      0 bytes  Base.Random.#shuffle!
                          sign      0 bytes  Base.#sign
                       signbit      0 bytes  Base.#signbit
                        signed      0 bytes  Base.#signed
                        signif      0 bytes  Base.#signif
                   significand      0 bytes  Base.Math.#significand
                       similar      0 bytes  Base.#similar
                           sin      0 bytes  Base.#sin
                          sinc      0 bytes  Base.Math.#sinc
                          sind      0 bytes  Base.Math.#sind
                          sinh      0 bytes  Base.#sinh
                         sinpi      0 bytes  Base.Math.#sinpi
                          size      0 bytes  Base.#size
                     sizehint!      0 bytes  Base.#sizehint!
                        sizeof      0 bytes  Base.#sizeof
                          skip      0 bytes  Base.#skip
                     skipchars      0 bytes  Base.#skipchars
                         sleep      0 bytes  Base.#sleep
                      slicedim      0 bytes  Base.#slicedim
                          sort      0 bytes  Base.#sort
                         sort!      0 bytes  Base.#sort!
                      sortcols      0 bytes  Base.Sort.#sortcols
                      sortperm      0 bytes  Base.#sortperm
                     sortperm!      0 bytes  Base.Sort.#sortperm!
                      sortrows      0 bytes  Base.Sort.#sortrows
                        sparse      0 bytes  Base.SparseArrays.#sparse
                     sparsevec      0 bytes  Base.SparseArrays.#sparsevec
                         spawn      0 bytes  Base.#spawn
                       spdiagm      0 bytes  Base.SparseArrays.#spdiagm
                         speye      0 bytes  Base.SparseArrays.#speye
                       splice!      0 bytes  Base.#splice!
                         split      0 bytes  Base.#split
                      splitdir      0 bytes  Base.Filesystem.#splitdir
                    splitdrive      0 bytes  Base.Filesystem.#splitdrive
                      splitext      0 bytes  Base.Filesystem.#splitext
                        spones      0 bytes  Base.SparseArrays.#spones
                        sprand      0 bytes  Base.SparseArrays.#sprand
                       sprandn      0 bytes  Base.SparseArrays.#sprandn
                        sprint      0 bytes  Base.#sprint
                       spzeros      0 bytes  Base.SparseArrays.#spzeros
                          sqrt      0 bytes  Base.#sqrt
                         sqrtm      0 bytes  Base.LinAlg.#sqrtm
                       squeeze      0 bytes  Base.#squeeze
                         srand      0 bytes  Base.Random.#srand
                    stacktrace      0 bytes  Base.StackTraces.#stacktrace
                         start      0 bytes  Base.#start
                    startswith      0 bytes  Base.#startswith
                          stat      0 bytes  Base.#stat
                           std      0 bytes  Base.#std
                          stdm      0 bytes  Base.#stdm
                          step      0 bytes  Base.#step
                        stride      0 bytes  Base.#stride
                       strides      0 bytes  Base.#strides
                        string      0 bytes  Base.#string
                    stringmime      0 bytes  Base.Multimedia.#stringmime
                         strip      0 bytes  Base.#strip
                      strwidth      0 bytes  Base.#strwidth
                       sub2ind      0 bytes  Base.#sub2ind
                      subtypes      0 bytes  Base.#subtypes
                       success      0 bytes  Base.#success
                           sum      0 bytes  Base.#sum
                          sum!      0 bytes  Base.#sum!
                       sum_kbn      0 bytes  Base.#sum_kbn
                        sumabs      0 bytes  Base.#sumabs
                       sumabs2      0 bytes  Base.#sumabs2
                       summary      0 bytes  Base.#summary
                     supertype      0 bytes  Base.#supertype
                           svd      0 bytes  Base.LinAlg.#svd
                       svdfact      0 bytes  Base.LinAlg.#svdfact
                      svdfact!      0 bytes  Base.LinAlg.#svdfact!
                          svds      0 bytes  Base.LinAlg.#svds
                       svdvals      0 bytes  Base.LinAlg.#svdvals
                      svdvals!      0 bytes  Base.LinAlg.#svdvals!
                     sylvester      0 bytes  Base.LinAlg.#sylvester
                       symdiff      0 bytes  Base.#symdiff
                      symdiff!      0 bytes  Base.#symdiff!
                       symlink      0 bytes  Base.Filesystem.#symlink
                   systemerror      0 bytes  Base.#systemerror
                         take!      0 bytes  Base.#take!
                 takebuf_array      0 bytes  Base.#takebuf_array
                takebuf_string      0 bytes  Base.#takebuf_string
                           tan      0 bytes  Base.#tan
                          tand      0 bytes  Base.Math.#tand
                          tanh      0 bytes  Base.#tanh
            task_local_storage      0 bytes  Base.#task_local_storage
                       tempdir      0 bytes  Base.Filesystem.#tempdir
                      tempname      0 bytes  Base.Filesystem.#tempname
                           tic      0 bytes  Base.#tic
                          time      0 bytes  Base.Libc.#time
                       time_ns      0 bytes  Base.#time_ns
                     timedwait      0 bytes  Base.#timedwait
                     titlecase      0 bytes  Base.#titlecase
                    to_indices      0 bytes  Base.#to_indices
                           toc      0 bytes  Base.#toc
                           toq      0 bytes  Base.#toq
                         touch      0 bytes  Base.Filesystem.#touch
                         trace      0 bytes  Base.LinAlg.#trace
                 trailing_ones      0 bytes  Base.#trailing_ones
                trailing_zeros      0 bytes  Base.#trailing_zeros
                     transcode      0 bytes  Base.#transcode
                     transpose      0 bytes  Base.#transpose
                    transpose!      0 bytes  Base.LinAlg.#transpose!
                      trigamma      0 bytes  Base.#trigamma
                          tril      0 bytes  Base.LinAlg.#tril
                         tril!      0 bytes  Base.LinAlg.#tril!
                          triu      0 bytes  Base.LinAlg.#triu
                         triu!      0 bytes  Base.LinAlg.#triu!
                         trues      0 bytes  Base.#trues
                         trunc      0 bytes  Base.#trunc
                      truncate      0 bytes  Base.#truncate
                       trylock      0 bytes  Base.#trylock
                      tryparse      0 bytes  Base.#tryparse
                 typeintersect      0 bytes  Base.#typeintersect
                      typejoin      0 bytes  Base.#typejoin
                       typemax      0 bytes  Base.#typemax
                       typemin      0 bytes  Base.#typemin
                       ucfirst      0 bytes  Base.#ucfirst
               unescape_string      0 bytes  Base.#unescape_string
                         union      0 bytes  Base.#union
                        union!      0 bytes  Base.#union!
                        unique      0 bytes  Base.#unique
                        unlock      0 bytes  Base.#unlock
                        unmark      0 bytes  Base.#unmark
                  unsafe_copy!      0 bytes  Base.#unsafe_copy!
                    unsafe_get      0 bytes  Base.#unsafe_get
                   unsafe_load      0 bytes  Base.#unsafe_load
      unsafe_pointer_to_objref      0 bytes  Base.#unsafe_pointer_to_objref
                   unsafe_read      0 bytes  Base.#unsafe_read
                 unsafe_store!      0 bytes  Base.#unsafe_store!
                 unsafe_string      0 bytes  Base.#unsafe_string
                  unsafe_trunc      0 bytes  Base.#unsafe_trunc
                   unsafe_wrap      0 bytes  Base.#unsafe_wrap
                  unsafe_write      0 bytes  Base.#unsafe_write
                      unshift!      0 bytes  Base.#unshift!
                      unsigned      0 bytes  Base.#unsigned
                         uperm      0 bytes  Base.Filesystem.#uperm
                     uppercase      0 bytes  Base.#uppercase
                       valtype      0 bytes  Base.#valtype
                        values      0 bytes  Base.#values
                           var      0 bytes  Base.#var
                          varm      0 bytes  Base.#varm
                          vcat      0 bytes  Base.#vcat
                           vec      0 bytes  Base.#vec
                        vecdot      0 bytes  Base.LinAlg.#vecdot
                       vecnorm      0 bytes  Base.LinAlg.#vecnorm
                   versioninfo      0 bytes  Base.#versioninfo
                          view      0 bytes  Base.#view
                          wait      0 bytes  Base.#wait
                       walkdir      0 bytes  Base.Filesystem.#walkdir
                          warn      0 bytes  Base.#warn
                    watch_file      0 bytes  Base.Filesystem.#watch_file
                         which      0 bytes  Base.#which
                          whos      0 bytes  Base.#whos
                       widemul      0 bytes  Base.#widemul
                         widen      0 bytes  Base.#widen
                       withenv      0 bytes  Base.#withenv
                       workers      0 bytes  Base.Distributed.#workers
                     workspace      0 bytes  Base.#workspace
                         write      0 bytes  Base.#write
                      writecsv      0 bytes  Base.DataFmt.#writecsv
                      writedlm      0 bytes  Base.DataFmt.#writedlm
                         xcorr      0 bytes  Base.DSP.#xcorr
                           xor      0 bytes  Base.#xor
                         yield      0 bytes  Base.#yield
                       yieldto      0 bytes  Base.#yieldto
                          zero      0 bytes  Base.#zero
                         zeros      0 bytes  Base.#zeros
                          zeta      0 bytes  Base.#zeta
                           zip      0 bytes  Base.Iterators.#zip
                             |      0 bytes  Base.#|
                            |>      0 bytes  Base.#|>
                             ~      0 bytes  Base.#~
                             ×      0 bytes  Base.LinAlg.#cross
                             ÷      0 bytes  Base.#div
                             γ      0 bytes  Irrational{:γ}
                             π      0 bytes  Irrational{:π}
                             φ      0 bytes  Irrational{:φ}
                             ∈      0 bytes  Base.#in
                             ∉      0 bytes  Base.#∉
                             ∋      0 bytes  Base.#∋
                             ∌      0 bytes  Base.#∌
                             ∘      0 bytes  Base.#∘
                             √      0 bytes  Base.#sqrt
                             ∛      0 bytes  Base.Math.#cbrt
                             ∩      0 bytes  Base.#intersect
                             ∪      0 bytes  Base.#union
                             ≈      0 bytes  Base.#isapprox
                             ≉      0 bytes  Base.#≉
                             ≠      0 bytes  Base.#!=
                             ≡      0 bytes  Core.#===
                             ≢      0 bytes  Base.#!==
                             ≤      0 bytes  Base.#<=
                             ≥      0 bytes  Base.#>=
                             ⊆      0 bytes  Base.#issubset
                             ⊈      0 bytes  Base.#⊈
                             ⊊      0 bytes  Base.#⊊
                             ⊻      0 bytes  Base.#xor
                             ⋅      0 bytes  Base.LinAlg.#dot

















In [ ]:

Content source: ivanslapnicar/GIAN-Applied-NLA-Course

Similar notebooks:

notebook.community | gallery | about